暂停并恢复一个C++；插入另一个 我有一个C++代码，里面有两个线程。在线程2中的事件“A”之后，线程1应该暂停（挂起），在线程2中执行更多的任务（比如事件“B”），最后线程1应该恢复。有没有办法做到这一点

我的代码如下所示：

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;
}

---

因为您似乎正在使用win32，所以可以使用

如果您想在pthreads中执行类似的操作，那么有一个

---

在这两种情况下，线程A将测试一个条件/事件（如果设置了，则等待；如果未设置，则继续），线程B将设置并清除该条件/事件。注意，根据线程a和线程B正在执行的操作，线程a和线程B之间可能还需要一个互斥锁，它们是否会相互损坏

嗨，我有一个例子是从cpp参考资料中得到启发的。 这个例子使用C++ 11，所以这个问题没有标记Win32，而是C++和多线程我张贴什么东西。 首先这里是原始链接

下面是我得到的解决问题的代码

#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 data\n";
    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 completed\n";
    }
    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 processed\n";
    }
    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;
}

#包括
#包括
#包括
#包括
#包括
std：：互斥m；
std：：条件变量cv；
std：：字符串数据；
bool ready=false；
bool-processed=false；
无效线程B_活动（）
{
//等待ThreadA（）发送数据
{
std：：唯一锁lk（m）；
cv.wait（lk，[{return ready；}）；
}
std：：你现在能这样做吗，有什么问题吗？毫无疑问，随机死锁。