Comment puis-je déterminer de manière fiable si un coup de pouce fil a quitté sa méthode run?

Je suppose recrutables indiquerait cela, cependant, il ne semble pas être le cas.

Dans une classe d'opérateur, j'ai tenté d'indiquer qu'il était toujours en cours de traitement par le biais d'un prédicat:

bool isRunning(){return thread_->joinable();}

Ne serait pas un fil qui est sorti de ne pas être joignable? Ce qui me manque... quel est le sens de boost thread::recrutables?

InformationsquelleAutor JeffV | 2009-11-03

boost c++multithreading

31

Puisque vous pouvez vous joindre à un fil, même après qu'il soit terminé, recrutables() renvoie toujours vrai jusqu'à ce que vous appelez join() ou detach(). Si vous voulez savoir si un thread est toujours en cours d'exécution, vous devriez être en mesure d'appeler timed_join avec un temps d'attente de 0. Notez que cela peut entraîner dans une situation de compétition depuis le thread peut mettre fin à droite après l'appel.
- C'est un peu trompeur de dire qu'il peut entraîner dans une course à condition. timed_join seul ne peut pas faire ça. si vous faites des hypothèses incorrectes sur la base du résultat de l'appel, vous pouvez vous retrouver avec une course à condition, bien sûr, mais c'est de moins en moins à voir avec timed_join qu'avec vous, en supposant que le résultat de cet appel est toujours valide. De toute façon, +1
- Je pense que c'est vraiment mauvais. Pourquoi faire le coup de pouce concepteurs ne pense jamais intuitivité ou de débutants. Un simple isRunning() la méthode aurait été suffisant. Au lieu de cela, ils obligent à utiliser une fonction qui devrait intuitivement pas être utilisé dans ce cas. Je ne veux pas chercher à rejoindre le fil, je veux juste tester rapidement si cela ne fonctionne toujours quelque chose. C'est de la merde. Perdu beaucoup de temps avant que je trouve cette. Pas un putain de mot dans les "docs", soit.
- Un thread peut être dans 3 états: en cours d'Exécution, Détaché, NotRunning.
- Bien Boost est fait par des gens comme vous. Si vous avez une proposition concrète, de le faire. Il sera encore mieux si vous fournissent en plus un patch de documentation et de tests.
- Cette réponse n'est pas valable que pour stimuler 1.55 sur windows : timed_joined() est obsolète, et l'appel try_join_for(0) renvoie la valeur false, sans vérifier si le thread a fini. Un patch a été publié pour les versions suivantes de boost, mais il n'est pas clair ce que le comportement prévu est de stimuler son point de vue développeur : svn.boost.org/trac/boost/ticket/9618
InformationsquelleAutor interjay
6

Utilisation thread::timed_join() avec un minimum de délai d'attente. Il retournera false si le fil est toujours en cours d'exécution.

Exemple de code:
```
thread_->timed_join(boost::posix_time::seconds(0));
```
- C'est faux. Si un thread détaché, elle retourne la valeur false. En effet vous avez besoin de le lire dans l'autre sens: retourne true si le thread est en cours d'exécution et s'est ensuite arrêté pendant le délai d'attente
- Pas exactement, le fil pourrait être arrêté et joignable lorsque vous appelez timed_join et que le résultat soit vrai.
InformationsquelleAutor Joakim Karlsson
3

Je suis d'utilisation de boost 1.54, par lequel l'étape timed_join() est obsolète. En fonction de votre utilisation, vous pouvez utiliser recrutables() qui fonctionne parfaitement pour mes fins, ou, alternativement, vous pouvez utiliser try_join_for() ou try_join_until(), voir:

http://www.boost.org/doc/libs/1_54_0/doc/html/thread/thread_management.html

InformationsquelleAutor pocruadhlaoich
2

Vous fondamentalement ne peut pas le faire. La raison en est que les deux réponses possibles sont "Oui" et "Pas la dernière fois que j'ai regardé, mais peut-être que maintenant". Il n'y a aucun moyen fiable de déterminer qu'un thread est toujours à l'intérieur de sa méthode run, même si il y avait un moyen fiable de déterminer le contraire.
- Vous fondamentalement peut ce faire. Vous pouvez de manière fiable la requête ou à "observer" le statut d'un thread à un moment donné. Le problème est juste que vous ne peut pas faire des hypothèses sur les interactions basées sur le statut que vous avez de nouveau, ce qui signifie le moment où vous avez l'info "le fil est toujours en cours d'exécution", il pourrait déjà avoir été arrêté dans le temps qu'il a fallu pour obtenir cette information, mais c'est rarement critique. Désolé mais ce post n'était pas du tout utile.
- Si vous ne pouvez pas faire toutes les hypothèses, comment cela pourrait-il être utile?
InformationsquelleAutor MSalters

C'est un peu brut, mais comme de maintenant, il travaille toujours pour mes besoins. 🙂 Je suis d'utilisation de boost 153 et qt. J'ai créé un vecteur d'int pour le suivi de l "état" de mon fils. Chaque fois que je créer un nouveau fil de discussion, j'ai ajouter une entrée à thread_ids avec une valeur de 0. Pour chaque thread créé, je passe un ID donc je sais ce que la partie de thread_ids je suis censé mettre à jour. Définir l'état à 1 pour la course et les autres valeurs en fonction de ce que je suis en train de faire donc je sais ce que l'activité était en cours au moment de la thread terminé. 100 est la valeur que j'ai mis pour un bien fini thread. Je ne sais pas si cela va vous aider mais si vous avez d'autres suggestions sur la façon d'améliorer ce laissez-moi savoir. 🙂

std::vector<int> thread_ids;
const int max_threads = 4;
void Thread01(int n, int n2)
{
    thread_ids.at(n) = 1;
    boost::this_thread::sleep(boost::posix_time::milliseconds(n2 * 1000));
    thread_ids.at(n) = 100;
    qDebug()<<"Done "<<n;

}
void getThreadsStatus()
{
    qDebug()<<"status:";
    for(int i = 0; i < max_threads, i < thread_ids.size(); i++)
    {
        qDebug()<<thread_ids.at(i);
    }
}
int main(int argc, char *argv[])
{
    for(int i = 0; i < max_threads; i++)
    {
        thread_ids.push_back(0);
        threadpool.create_thread(
            boost::bind(&boost::asio::io_service::run, &ioService));
        ioService.post(boost::bind(Thread01, i, i + 2));
        getThreadsStatus();
    }

    ioService.stop();
    threadpool.join_all();
    getThreadsStatus();
}

InformationsquelleAutor Adonai

0

Le moyen le plus facile, si la fonction qui exécute votre fil est assez simple, est de définir une variable à true lorsque la fonction est terminée. Bien sûr, vous aurez besoin d'une variable par thread, si vous avez beaucoup d'une carte d'id de thread et l'état, peuvent être une meilleure option. Je sais que c'est fabriqué à la main, mais il fonctionne très bien en attendant.
```
class ThreadCreator
{
private:
    bool            m_threadFinished;
    void launchProducerThread(){
        //do stuff here
        m_threadRunning = true;
    }
public:
    ThreadCreator() : m_threadFinished(false) {
        boost::thread(&Consumer::launchProducerThread, this);
    }
};
```
InformationsquelleAutor Blackzafiro
0

Cela peut ne pas être une réponse directe à votre question, mais je vois le fil concept vraiment mécanisme léger, et volontairement dépourvu de de tout, sauf de la synchronisation des mécanismes. Je pense que le bon endroit pour mettre "est en cours d'exécution" est dans la classe qui définit la fonction de thread. Notez que d'un point de vue de la conception, vous pouvez quitter le fil sur l'interruption et toujours pas votre travail terminé. Si vous voulez nettoyer le fil après qu'il est terminé, vous pouvez l'envelopper dans un coffre-fort pointeur et le remettre à la catégorie des travailleurs.
- Je crois qu'il serait mieux si vous clarifier avec des exemples de code et de diviser votre texte en paragraphes pour faciliter la lecture.
InformationsquelleAutor Brian Balke

Vous devez vous connecter pour publier un commentaire.