Bonne façon de mettre en pause, & reprendre un std::thread

Je suis en utilisant un std::thread dans mon C++ code de constamment sondage pour certaines données & ajouter à un tampon. J'utilise un C++ lambda pour démarrer le thread comme celui-ci:

StartMyThread() {

    thread_running = true;
    the_thread = std::thread { [this] {
        while(thread_running) {
          GetData();
        }
    }};
}

thread_running est un atomic<bool> déclaré dans l'en-tête de classe. Voici mon GetData fonction:

GetData() {
    //Some heavy logic which needs to be executed in a worker thread
}

Prochaine j'ai aussi un StopMyThread fonction où j'ai mis thread_running de faux, de sorte qu'il sort de la boucle while dans la lambda block.

StopMyThread() {
  thread_running = false;
  the_thread.join();
}

Il fonctionne bien. La discussion commence & arrête sans s'écraser.

Ce code C++ est utilisé sur iOS, Android, OS X et Windows. Mon INTERFACE utilisateur de l'application dispose d'un bouton qui m'oblige à commencer & arrêter le fil sur simple pression d'un bouton, ce bouton peut être fréquemment utilisé dans certaines occasions. Je peux voir une fraction de seconde de retard dans l'INTERFACE utilisateur, tandis que d'arrêter ou de démarrer le thread.

Ma question est: En C++, est-ce une bonne façon de démarrer/arrêter un thread fréquemment ? Je pense qu'avec cette logique, je suis entrain de créer un nouveau thread à chaque fois. Et comme je vous comprends, la création d'un nouveau thread utilise l'OS allouer beaucoup de nouvelles ressources, ce qui peut être consoming. Et je pense que c'est l'erreur que j'ai fais. Comment puis-je éviter cela ?

Comment pouvez utiliser le même fil, sans allouer de nouveaux de un à plusieurs reprises tout au long du cycle de vie des applications, et tout simplement jouer/pause quand il le faut ?

Le délai peut également être attends-tu pour l'ancien fil de sortie. (Si vous avez deux threads à l'aide de la même thread_running valeur, vous aurez douleur!)
Vous pouvez mettre en pause un fil en le faisant attendre sur un std::mutex.
Attention: Reportez-vous à blogs.msdn.microsoft.com/oldnewthing/20031209-00/?p=41573 pourquoi un général suspend_thread fonction ne va pas être une bonne idée. (L'exemple est sur C# sur Windows, mais les principes s'appliquent partout.) Si vous utilisez un mutex pour le faire attendre, vous aurez à réfléchir sur le blocage de l'UI thread.
Pas exactement sur le point, mais connexes: jetez un oeil à boost::coroutine, il est assez cool.
std::mutex + std::condition_variable. Le resume fonction juste ne ` notify_one

OriginalL'auteur Game_Of_Threads | 2016-11-11

c++c++11 c++14 lambda stdthread

5

C'est l'exemple classique de l'utilisation d'une variable de condition. Vous attendez un mutex et informer un thread lorsqu'une certaine condition est remplie; de cette façon, vous n'avez pas besoin d'allouer un nouveau fil de discussion lorsque vous en avez besoin, mais ce n'est pas toujours une bonne chose, si vous souhaitez économiser de la mémoire. Une alternative serait une coroutine céder à un autre coroutine lorsque les données sont nécessaires, ce qui est sans doute plus joli. Vous avez besoin de mettre en œuvre des coroutines vous-même, ou l'utilisation d'un ready-made de la bibliothèque, comme boost.coroutine.

Exemple
```
::std::condition_variable cv_;
::std::mutex m_;
bool data_is_ready_{};

StartMyThread()
{
  ::std::thread([this]
    {
      for (;;)
      {
        ::std::unique_lock<decltype(m_)> l(m_);
        cv.wait(l, [this]{ return data_is_ready_; });

        //do your stuff, m_ is locked
        data_is_ready_ = false;
      }
    }
  ).detach();
}
```
À notifier:
```
{
  ::std::unique_lock<decltype(m_)> l(m_);

  data_is_ready_ = true;
}

cv_.notify_one();
```
Comme il est souvent plus rapide pour libérer le verrou avant de notifier, que vice-versa.

N'avez-vous pas manqué pour verrouiller le mutex à l'intérieur du fil? cv.attendre ne sera pas verrouiller, elle attend un verrouillé mutex et déverrouiller pendant l'attente.
Un nit-pick. Pourquoi qualifier entièrement std espace de noms ? C'est moche et inutile, sauf si vous avez quelque chose de méchant et le mal.
pourquoi utilisez-vous un .detach à la fin. Ne serait-ce pas en faire un daemon fil ?
Ouais, c'est un décollement de fil, mais il sait à propos de join(), de sorte qu'il peut le faire différemment.
grâce T. C. correction de la réponse

OriginalL'auteur user1095108

Vous devez vous connecter pour publier un commentaire.

Exemple