Uso de GCD y reutilización de código: evitando interlocking de código reentrenado

Estoy usando GCD para agregar security de subprocesss a una class.

Algunos methods públicos de mi class son llamados por otros methods públicos en la class. Sin embargo, esto conduce al problema de locking de reinput: si protejo los methods públicamente visibles apropiados con bloques síncronos de GCD (en algunos casos), la reutilización significa que a veces intentaré ejecutar otro bloque síncrono en la queue actual , lo que lleva a un punto muerto.

¿Cuál es la solución más elegante? Un enfoque obvio es tener versiones internas de los methods apropiados, sin ningún bloque GCD, y versiones públicas externas del método que tienen los bloques GCD enviando llamadas a los methods internos. Esto no me parece bien.

Aquí hay algunos pensamientos:

  1. Mira si no puedes usar objects inmutables. Esto significa que cada vez que un método modifica el object, en realidad devuelve un nuevo object con el estado modificado. Los bloques continuarían y usarían este nuevo object. Esto es simple, no requiere cuidado especial, pero no siempre es posible.

  2. Vea si sus methods públicos no pueden usar methods privados que transportan el estado. Dado que cada bloque llevaría su propio estado interno, entonces también es seguro para el hilo.

Si tuviera un ejemplo de caso de uso, podría dar lugar a más ideas …

He utilizado un patrón como este con mucho éxito en nuestras classs de C ++ que utilizan queues de envío para la synchronization:

class Foo { public: void doSomething() { dispatch_sync(fQueue, ^{ doSomething_sync(); }); } private: void doSomething_sync() { ... } private: dispatch_queue_t fQueue; }; 

La convención general aquí es que para cualquier método _sync dado en una class, solo _sync otros methods _sync y no su contraparte pública no _sync .