Programmation multithread

Question

Existe-t-il un appel de fonction qui peut être associé à un thread spécifique pour le faire fonctionner ou attendre ? J'ai 4 threads dans mon programme et j'essaie de trouver un moyen de dire à l'un des threads d'attendre ou de s'exécuter quand je le veux.

Answer 1

Votre question est assez générale. Elle se résume en fait à : Revoyez la documentation de pthreads.

Si ce que vous voulez, c'est que le fil A attende que le fil B se termine, consultez le site suivant pthread_join() .

Si vous voulez que le fil A attende que le fil B dise qu'il peut continuer, vous aurez besoin d'un mutex et d'une variable conditionnelle. Consultez pthread_cond_wait() et les fonctions associées.

Answer 2

Un mécanisme courant pour gérer plusieurs threads est une approche maître/esclave dans laquelle un thread confie des tâches aux autres. L'essentiel de ce style, et je pense que c'est ce à quoi vous voulez en venir, est de réaliser que même dans les threads esclaves, chaque thread a par nature un contrôle total sur sa propre exécution. . Le maître ne "force" pas vraiment les autres threads à faire quoi que ce soit, le maître peut faire une demande mais le thread esclave doit volontairement accepter les instructions du maître... hrm... alors peut-être que maître/esclave est un terme mal choisi ici... Quoi qu'il en soit, la solution commune pour les fils esclaves est en pseudocode

while (!should_exit):
    while (!have_something_to_do):
        wait_for_something_to_do()
    do_the_thing_i_was_waiting_for()

Vous pouvez mettre en œuvre cette stratégie assez facilement en C en utilisant une structure comme la suivante (j'ai recours à un code pseudo-c pour les besoins de l'exemple)

struct Slave {
    Mutex              thread_lock;
    ConditionVariable  thread_cv;
    int                exit_flag;
    void             (*thread_operation)();
};

void slave_thread( Slave * slave ) {
    while( !exit_flag )
    {
        lock( thread_lock );
        while( slave->thread_operation == NULL )
            slave->thread_cv.wait( thread_lock );
        unlock( thread_lock );
        (*slave->thread_operation)(); // do the master's bidding...
    }
}

void master_thread()
{
   Slave slave1;
   Slave slave2;

   slave1.thread_operation = NULL;
   slave2.thread_operation = NULL;

   // create the threads. They'll immediately block on the condition variable

   slave1.thread_operation = some_function_pointer;
   slave2.thread_operation = some_other_function_pointer;

   notify_one( slave1.thread_cv ) // Now that the function pointers are set, wake
   notify_one( slave2.thread_cv ) // the slave threads

}

Il s'agit bien sûr d'un exemple trop simpliste, mais j'espère qu'il vous donnera une idée générale.