Linux Threads suspendre/reprendre

Cette question n'est pas sur la façon d'utiliser les mutex, mais comment faire pour suspendre à un fil.

Dans les spécifications Unix il y a une fonction de thread appelé pthread_suspend, et un autre appelé pthread_resume_np, mais pour une raison quelconque, les gens qui font de Linux, FreeBSD, NetBSD, et ainsi de suite n'ont pas mis en œuvre ces fonctions.

Afin de les comprendre, les fonctions ne sont tout simplement pas là. Il existe des solutions de contournement, mais malheureusement il n'est juste pas la même que l'appel à la SuspendThread sur windows. Que vous avez à faire tous les types de non-portable trucs pour faire un fil d'arrêter et de commencer à l'aide de signaux.

D'arrêt et de reprise des threads est vital pour les débogueurs et ramasseurs d'ordures. Par exemple, j'ai vu une version de Wine qui n'est pas capable de mettre en œuvre le "SuspendThread" de la fonction. Ainsi, tout programme windows en utilisant il ne fonctionnera pas correctement.

J'ai pensé qu'il était possible de le faire correctement à l'aide des signaux basé sur le fait que la JVM utilise cette technique de signaux pour le Garbage collector, mais j'ai aussi vu quelques articles en ligne où les gens remarquent les blocages et ainsi de suite avec la JVM, parfois unreproducable.

De sorte à arriver à répondre à la question, vous ne parvenez pas à suspendre et de reprendre les discussions avec Unix, sauf si vous avez une belle Unix qui implémente pthread_suspend_np. Sinon, vous êtes coincé avec les signaux.

Le gros problème avec les Signaux, c'est quand vous avez environ cinq bibliothèques différentes, toutes reliées au même programme et tous les mêmes signaux en même temps. Pour cette raison, je crois que vous ne pouvez utiliser quelque chose comme ValGrind, par exemple, le GC de Boehm dans un seul programme. Au moins sans codage au niveau le plus bas de l'espace utilisateur.

Une autre réponse à cette question pourrait être. Faire ce Linuz Torvalds n'NVidia, retournez le doigt sur lui et l'amener à mettre en œuvre les deux parties essentielles manquantes à partir de Linux. Tout d'abord, pthread_suspend, et la seconde, une sale peu sur les pages de mémoire, de sorte que la bonne éboueurs peuvent être mises en œuvre. Lancer une grande pétition en ligne et rester appuyer sur le doigt. Peut-être par les Fenêtres de temps de 20 sort, ils se rendront compte que la Suspension et la reprise de threads, et ayant sale bits est en fait l'une des raisons fondamentales de Windows et Mac sont mieux que Linux, ou tout Unix qui ne mettent pas en œuvre pthread_suspend et aussi un sale peu sur les pages virtuelles, comme VirtualAlloc dans Windows.

Je ne pas vivre dans l'espérance. En fait pour moi, j'ai passé un certain nombre d'années, la planification de mon avenir autour de la construction des trucs pour Linux, mais ont abandonné l'espoir fiable chose tout semble dépendre de la disponibilité d'un bit d'impureté pour la mémoire virtuelle, et pour suspendre les fils proprement.

OriginalL'auteur

Il n'y a pas de pthread_suspend(), pthread_resume() type d'Api POSIX.

Pour la plupart des variables de condition peut être utilisé pour contrôler l'exécution des autres threads.

De la variable de condition mécanisme permet aux threads de suspendre l'exécution
et renoncer à son processeur jusqu'à ce qu'une condition est vraie. Une condition
variable doit toujours être associé à un mutex pour éviter une course
condition créé par un fil de la préparation d'attendre et d'un autre thread
qui peut témoigner de la condition avant le premier thread attend réellement
sur qu'il en résulte un blocage.

Pour plus d'info

Pthreads

Linux Tutoriel Threads Posix

OriginalL'auteur Jeyaram

Vous pouvez utiliser les mutex pour ce faire, le pseudo-code serait:

While (true) {
    /* pause resume */
    lock(my_lock); /* if this is locked by thread1, thread2 will wait until thread1 */
                   /* unlocks it */
    unlock(my_lock); /* unlock so that next iteration thread2 could lock */

    /* do actual work here */
}

OriginalL'auteur aisbaa

Pour la mise en œuvre de la pause sur un fil, vous avez besoin de le faire attendre un événement se produise. En attente sur un spin-lock mutex est CPU cycle de gaspiller. À mon humble avis, cette méthode ne doit pas être suivi comme les cycles de PROCESSEUR pourrait avoir été utilisé par d'autres processus/threads.
Attendre sur un non-descripteur de blocage (pipe, socket ou une autre). Exemple de code pour l'utilisation de des tuyaux pour la communication inter-thread peut être vu ici
Solution ci-dessus est utile, si votre deuxième thread a plus d'informations à partir de plusieurs sources que de simplement le mettre en pause et reprendre des signaux. Un haut niveau select/poll/epoll peut être utilisé sur la non-blocage des descripteurs. Vous pouvez spécifier le temps d'attente pour les select/poll/epoll les appels système, et seulement ce micro-secondes de cycles CPU sera gaspillé.
Je vous parle de cette solution avant-gardiste que votre deuxième thread aura plus de choses ou d'événements à gérer que de la pause et de reprise. Désolé si c'est plus détaillé que ce que vous avez demandé.

Une autre approche la plus simple peut être d'avoir partagé variable booléenne entre ces threads.
Thread principal est l'écrivain de la variable, de 0 signifie arrêter. 1 - signifie reprendre
Deuxième thread ne lit la valeur de la variable. Pour mettre en œuvre '0' état, l'utilisation usleep pour sime micro-secondes, puis vérifiez de nouveau la valeur. En supposant que, quelques micro-secondes de retard est acceptable dans votre conception.
Pour mettre en œuvre '1' - vérifier la valeur de la variable après avoir fait un certain nombre d'opérations.
Sinon, vous pouvez également mettre en place un signal pour passer de '1' à '0' état.

OriginalL'auteur Groovy