Suspendre et reprendre un thread C ++ dans un autre - c ++, multithreading, winapi

J'ai un code C ++ avec deux threads. Après un événement "A" dans le fil 2, le fil 1 doit être suspendu (suspendu), certaines tâches supplémentaires doivent être exécutées dans le fil 2 (par exemple, l'événement "B") et enfin le fil 1 doit être repris. Y a-t-il un moyen de faire ça?

Mon code ressemble à ceci:

HANDLE C;
DWORD WINAPI A (LPVOID in)
{
while(1){
// some operation
}
return 0;
}

DWORD WINAPI B (LPVOID in)
{
while(1){

//Event A occurs here

SuspendThread (C);

//Event B occurs here

ResumeThread (C);
}
return 0;
}

int main()
{
C = CreateThread (NULL, 0, A, NULL, 0, NULL);
CreateThread (NULL, 0, B, NULL, 0, NULL);
return 0;
}

Réponses:

Bonjour, j'ai un exemple inspiré de la référence cpp. L'exemple utilise C ++ 11, étant donné que cette question n'a pas été signalée par win32, mais c ++ et multithreading, je poste quelque chose.

Tout d'abord, voici le lien original.

http://en.cppreference.com/w/cpp/thread/sleep_for

Maintenant, voici le code que j'ai obtenu qui résout le problème.

#include <iostream>
#include <string>
#include <thread>
#include <mutex>
#include <condition_variable>

std::mutex m;
std::condition_variable cv;
std::string data;
bool ready = false;
bool processed = false;

void ThreadB_Activity()
{
// Wait until ThreadA() sends data
{
std::unique_lock<std::mutex> lk(m);
cv.wait(lk, []{return ready;});
}

std::cout << "Thread B is processing datan";
data += " after processing";
// Send data back to ThreadA through the condition variable
{
std::lock_guard<std::mutex> lk(m);
processed = true;
std::cout << "Thread B signals data processing completedn";
}
cv.notify_one();
}


void ThreadA_Activity()
{
std::cout<<"Thread A started "<<std::endl;
data = "Example data";
// send data to the worker thread
{
std::lock_guard<std::mutex> lk(m);
ready = true;
std::cout << "Thread A signals data are ready to be processedn";
}
cv.notify_one();//notify to ThreadB that he can start doing his job

// wait for the Thread B
{
std::unique_lock<std::mutex> lk(m);
cv.wait(lk, []{return processed;});
}
std::cout << "Back in Thread A , data = " << data << "n";

std::this_thread::sleep_for( std::chrono::milliseconds( 1000 ));
std::cout<<"end of Thread A"<<std::endl;
}


int main()
{
std::thread ThreadB(ThreadB_Activity);
std::thread ThreadA(ThreadA_Activity);

ThreadB.join();
ThreadA.join();

std::cout << "Back in main , data = " << data << "n";
return 0;
}

J'espère que ça aide, tous les commentaires sont les bienvenus :-)

Comme vous semblez utiliser win32, vous pouvez utiliser un un événement

Si vous voulez faire quelque chose de similaire dans pthreads il y a un exemple ici.

Dans les deux cas, le thread A testera uncondition / event (et attendez si elle est définie ou continuez si ce n'est pas le cas) et le thread B définira et effacera la condition / event. Notez que vous pourriez également avoir besoin d'un mutex entre les threads A et B selon ce qu'ils font, peuvent-ils se corrompre?