modèle de conception pour l'exécution simultanée de tâches avec des contraintes

Question

J'ai 3 classes de tâche (I, D, U) qui entrent dans une file d'attente, les tâches de la même classe doivent être traitées dans l'ordre. Je veux que les tâches s'exécutent aussi simultanément que possible; mais il y a des contraintes:

• U et D ne peuvent pas fonctionner en même temps
• U et je ne peux pas exécuter simultanément
• I (n) nécessite U (n) a terminé

Q: Quel (s) motif (s) de conception correspondraient à cette catégorie de problème?

J'ai deux approches j'envisage:

Approche 1: Utiliser 1 fil par tâche, chacun avec sa propre file d'attente. Chaque thread a une phase de démarrage synchronisée où il vérifie les conditions de démarrage, puis s'exécute, puis une phase d'arrêt synchronisée. Il est facile de voir que cela fournira une bonne simultanéité, mais je ne suis pas sûr si elle implémente correctement mes contraintes et ne se bloque pas.

D_Thread { ... 
while (task = D_Queue.take()) { 
    synchronized (State) { // start phase 
    waitForU(); 
    State.setRunning(D, true); 
    } 
    run(task); // run phase 
    synchronized (State) { // stop phase 
    State.setRunning(D, false) 
    } 
} 
} 

Approche 2: Alternativement, un seul thread d'expédition gère l'état d'exécution et tâches horaires dans un ThreadPool, en attendant si nécessaire pour des tâches actuellement prévues pour terminer.

Answer 1

L'infrastructure Objective-C Foundation comprend les classes NSOperationQueue et NSOperation qui répondent à certaines de ces exigences. NSOperationQueue représente une file d'attente de NSOperation s. La file d'attente exécute un nombre maximal configurable d'opérations simultanément. Les opérations ont une priorité et un ensemble de dépendances; toutes les opérations dont dépend une opération doivent être terminées avant que la file d'attente ne commence à exécuter l'opération. Les opérations sont planifiées pour s'exécuter sur un pool de threads de taille dynamique.

Qu'est-ce que vous avez besoin nécessite une version un peu plus intelligent de NSOperationQueue qui applique les contraintes que vous avez exprimées, mais NSOperationQueue et société fournissent un exemple de la façon dont à peu près votre problème a été résolu dans un cadre de production qui ressemble à votre deuxième solution proposée d'une dépêche thread exécute des tâches sur un pool de threads.

Answer 2

En fait, cela se révèle être plus simple que cela semblait: un mutex est surtout tout ce qui est nécessaire:

IThread(int k) { 
synchronized (u_mutex) { 
    if (previousUSet.contains(k))) U(k); 
} 
I(k); 
} 

DThread(int k) { 
synchronized (u_mutex) { 
    D(k); 
    previousUSet.add(k); 
} 
}