WaitForSingleObject et WaitForMultipleObjects équivalent sous Linux?

Je suis de la migration d'une application de windows à linux. Je suis confronté à problème à l'égard de WaitForSingleObject et WaitForMultipleObjects interfaces.

Dans mon application, j'ai engendrer de multiples threads où tous les threads en attente pour les événements de processus parent ou d'exécuter régulièrement pour toutes les t secondes.

J'ai vérifié pthread_cond_timedwait, mais nous avons à spécifier temps absolu pour cette.

Comment puis-je mettre en œuvre cette sous Unix?

InformationsquelleAutor Poorna | 2010-04-27
  1. 12

    En tenir à pthread_cond_timedwait et l'utilisation clock_gettime. Par exemple:

    struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
ts.tv_sec += 10; //ten seconds
while (!some_condition && ret == 0)
    ret = pthread_cond_timedwait(&cond, &mutex, &ts);

    L'envelopper dans une fonction si vous le souhaitez.

    Mise à JOUR: en complément de la réponse basée sur nos observations.

    POSIX n'ont pas une seule API pour attendre "tous les types" des événements ou des objets que Windows ne. Chacun a ses propres fonctions. La façon la plus simple d'informer d'un thread pour la résiliation est à l'aide atomique variables/opérations. Par exemple:

    Thread principal:

    //Declare it globally (argh!) or pass by argument when the thread is created
atomic_t must_terminate = ATOMIC_INIT(0);

//"Signal" termination by changing the initial value
atomic_inc(&must_terminate);

    Thread secondaire:

    //While it holds the default value
while (atomic_read(&must_terminate) == 0) {
    //Keep it running...
}
//Do proper cleanup, if needed
//Call pthread_exit() providing the exit status

    Une autre alternative est d'envoyer une demande d'annulation à l'aide de pthread_cancel. Le fil annulé doit avoir appelé pthread_cleanup_push pour vous inscrire nettoyage nécessaire de gestionnaire. Ces gestionnaires sont appelés dans l'ordre inverse de leur enregistrement. Ne jamais appeler pthread_exit à partir d'un gestionnaire de nettoyage, parce que c'est un comportement indéterminé. Le statut de sortie de l'annulation de la thread est PTHREAD_CANCELED. Si vous optez pour cette solution, je vous recommande de lire principalement sur les points d'annulation et de types.

    Et le dernier mais non le moindre, l'appel de pthread_join fera le thread en cours de bloquer jusqu'à ce que le fil passé en argument se termine. En bonus, vous aurez le fil de sortie du statut.

    • Mais est-il obligatoire sur cond signal pour les threads qui attendent le signal pour verrouiller le mutex et de vérifier l'état de la variable, même si elles ne sont pas valoir pour toute ressource.
    • POSIX n'ont pas une seule API pour attendre "tous les types" des événements ou des objets. Chacun a ses propres fonctions. Si vous spécifiez le type d'événement qui vous intéresse, je pourrais être en mesure d'indiquer le plus approprié de l'API.
    • Dans mon application je veux que chaque thread généré par la société mère de fil à attendre pour mettre fin à l'événement du parent et de faire du nettoyage sur la fin et le parent d'attendre jusqu'à ce que tous donné naissance à des threads sont terminées
    • Qu'entendez-vous par terminate event? Une variable atomique partagée par tous les threads? Ou si vous voulez une suggestion de moi? Pour le parent-attendre-filetage de la partie, vous pouvez séquentiellement appel pthread_join pour chaque fil que vous souhaitez attendre.
    • Je dois y aller maintenant, mais ma suggestion pour le terminate event sans verrouillage, est une variable atomique, ou pthread_cancel+ pthread_cleanup_push. La première envoie une demande d'annulation de l'souhaité fil, et le second registres de nettoyage des rappels, et elle doit être invoquée par le fil lui-même. Le nettoyage des rappels sera invoquée lors d'une demande d'annulation. Je vous recommande de lire plus sur ce sujet, principalement des points d'annulation et de types. J'espère que cela va répondre à vos question(s).
    • Je vais modifier ma réponse plus tard (quand je les aurai du temps libre) pour inclure toutes ces informations.
    • Nous avons utilisé ACE cadre, donc résolu à l'aide de ACE thread groupes et nous pouvons répondre à l'ensemble d'un groupe de thread avec un message d'événement et parent thread attend tous les fils à la sortie.
    • Vous pouvez voir ma réponse pour une autre option quand il s'agit de WaitForMultipleObjects.
    • Salut, ce qu'il faut inclure pour obtenir des opérations atomiques? J'ai essayé #include <atomic.h> et #include <asm/atomic.h> et les deux n'existe pas.
    • jusqu'à ce C11 (et C++11, fwiw) est venu à la vie, il n'y a pas de standard façon d'utiliser les opérations atomiques. Cependant, la plupart des compilateurs déjà fourni leurs propres implémentations (GCC par exemple). Le Noyau Linux fournit sa propre mise en œuvre (ce qui est le seul que j'ai utilisé dans la réponse). Utiliser le noyau impl, installer les en-têtes du noyau & ajouter ses include dir pour le "chemin" pour la compilation - alors il va trouver de l'en-tête requis, <asm/atomic.h>.
    • Mise à jour du lien: Noyau Linux fournit sa propre mise en œuvre. Le précédent est aujourd'hui brisé.

    InformationsquelleAutor jweyrich
  2. 12

    Pour ce que ça vaut, nous (NeoSmart Technologies) vient de publier un open source (sous licence MIT) bibliothèque appelée pevents qui met en œuvre WIN32 manuel et auto-reset événements sur POSIX, et comprend à la fois WaitForSingleObject et WaitForMultipleObjects clones.

    Bien que je serais personnellement vous conseillons d'utiliser POSIX multithreading et la signalisation des paradigmes lors du codage sur POSIX machines, pevents vous donne un autre choix si vous en avez besoin.

    InformationsquelleAutor Mahmoud Al-Qudsi
  3. 1

    Je sais que c'est une vieille question maintenant, mais pour quelqu'un d'autre qui trébuche à travers elle, cette source suggère que pthread_join() n'est effectivement la même chose que WaitForSingleObject():

    http://www.ibm.com/developerworks/linux/library/l-ipc2lin1/index.html

    Bonne chance!

    • WaitForSingleObject, WaitForMultipleObjects et les amis aussi prendre un timout. Je ne crois pas pthread_join fournit.
    • pthread_timedjoin_np si elle est disponible sur votre système, fournit un paramètre de délai d'attente
    • votre lien ne semble pas pointer vers le bon endroit. Je suis à la planification de l'utilisation de votre réponse. encore bonne en 2019?
    InformationsquelleAutor eskimo9
  4. 1

    Pour WaitForMultipleObjects avec de faux WaitAll essayez ceci:

    #include <unistd.h>
#include <pthread.h>
#include <stdio.h>
using namespace std;
pthread_cond_t condition;
pthread_mutex_t signalMutex;
pthread_mutex_t eventMutex;
int finishedTask = -1;
void* task(void *data)
{
int num = *(int*)data;
//Do some
sleep(9-num);
//Task finished
pthread_mutex_lock(&eventMutex); //lock until the event will be processed by main thread
pthread_mutex_lock(&signalMutex); //lock condition mutex
finishedTask = num; //memorize task number
pthread_cond_signal(&condition);
pthread_mutex_unlock(&signalMutex); //unlock condtion mutex
}
int main(int argc, char *argv[])
{
pthread_t thread[10];
pthread_cond_init(&condition, NULL);
pthread_mutex_init(&signalMutex, NULL); //First mutex locks signal
pthread_mutex_init(&eventMutex, NULL); //Second mutex locks event processing
int numbers[10];
for (int i = 0; i < 10; i++) {
numbers[i] = i;
printf("created %d\n", i); //Creating 10 asynchronous tasks
pthread_create(&thread[i], NULL, task, &numbers[i]);
}
for (int i = 0; i < 10;)
{
if (finishedTask >= 0) {
printf("Task %d finished\n", finishedTask); //handle event
finishedTask = -1; //reset event variable
i++;
pthread_mutex_unlock(&eventMutex); //unlock event mutex after handling
} else {
pthread_cond_wait(&condition, &signalMutex); //waiting for event
}
}
return 0;
}
    InformationsquelleAutor Sorcerer