如何在c++；？ 我需要用原始同步对象——事件来解决C++中的生产者-消费者问题，我已经写了这个代码 static int g_x = 0; HANDLE hEvent1; HANDLE aThread[2]; DWORD ThreadID; //tread 1 void Producer() { for (int i = 0; i < 100; ++i) { WaitForSingleObject(hEvent1, INFINITE); g_x = i; SetEvent(hEvent1); } } //thread 2 void Consumer() { for (;;) { WaitForSingleObject(hEvent1, INFINITE); SetEvent(hEvent1); } } int createthreads() { hEvent1 = CreateEvent(NULL, FALSE, TRUE, NULL); // Create worker threads aThread[0] = CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)Producer, NULL, 0, &ThreadID); aThread[1] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)Consumer, NULL, 0, &ThreadID); } int main() { createthreads(); } static int g_x=0； 处理hEvent1； 句柄aThread[2]； 德沃德·特莱德； //踏面1 无效生产者（） { 对于（int i=0；iConsumer（）； 退出线程（0）； } 无效消费者（） { 对于（；；） { WaitForSingleObject（hLowEvent，无限）； DbgPrint（“%u\n”，_x）； 如果（退出） { 返回； } SetEvent（hHighEvent）； } } }; void testPC（） { 共享数据sd； 如果（！sd.Create（）） { 句柄hThreads[2]={}； if（hThreads[0]=CreateThread（0,0，SharedData:：_Producer，&sd，0,0）） { if（hThreads[1]=CreateThread（0,0，SharedData:：u Consumer，&sd，0,0）） { WaitForMultipleObjects（2，hThreads，TRUE，无限）； CloseHandle（hThreads[1]）； } 其他的 { sd.\u quit=true； SetEvent（sd.hHighEvent）； WaitForSingleObject（hThreads[0]，无限）； } } CloseHandle（hThreads[0]）； } } 对于此类代码，需要使用2个事件。我认为，对生产者线程和消费者线程使用1个事件将导致本博客描述的痛苦createthreads必须返回一个值-并且必须是u stdcall，带有一个参数）两个线程都从WaitForSingleObject开始-在这种情况下都挂起。需要先设置一个事件吗call@RbMm是的，你需要的就是这个@Fsdfdsg你很好！使用信号量而不是事件将支持多个生产者和多个消费者

此代码无法正常工作：我有无限循环

---

如何修复此代码以将控制台编号从

0

转到

99

您需要另一个事件来同步这两个线程。 我还将两个事件的初始状态设置为

FALSE

，并在

main

通过这种方式，您可以控制流程的启动时间和方式

和Offtopic，

createthreads

必须返回一个值

static int g_x = 0;
HANDLE hEvent1;
HANDLE hEvent2;

HANDLE aThread[2];
DWORD ThreadID;

//tread 1
void Producer()
{
    for (int i = 0; i < 100; ++i)
    {
        WaitForSingleObject(hEvent1, INFINITE);
        g_x = i;
        SetEvent(hEvent2);
    }
}
//thread 2
void Consumer()
{
    for (;;)
    {
        WaitForSingleObject(hEvent2, INFINITE);
        SetEvent(hEvent1);
    }
}

int createthreads() {
    hEvent1 = CreateEvent(NULL, FALSE, FALSE, NULL);
    hEvent2 = CreateEvent(NULL, FALSE, FALSE, NULL);

    // Create worker threads
    aThread[0] = CreateThread( NULL, 0, (LPTHREAD_START_ROUTINE)Producer, NULL,  0, &ThreadID);
    aThread[1] = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)Consumer, NULL, 0, &ThreadID);
    return 0;
}
int main() {
    createthreads();
    SetEvent(hEvent1);
}

static int g_x=0；
处理hEvent1；
把手2；
句柄aThread[2]；
德沃德·特莱德；
//踏面1
无效生产者（）
{
对于（int i=0；i<100；++i）
{
WaitForSingleObject（hEvent1，无限）；
g_x=i；
SetEvent（hEvent2）；
}
}
//线程2
无效消费者（）
{
对于（；；）
{
WaitForSingleObject（hEvent2，无限）；
SetEvent（hEvent1）；
}
}
int createthreads（）{
hEvent1=CreateEvent（NULL，FALSE，FALSE，NULL）；
hEvent2=CreateEvent（NULL，FALSE，FALSE，NULL）；
//创建工作线程
aThread[0]=CreateThread（NULL，0，（LPTHREAD\u START\u例程）Producer，NULL，0，&ThreadID）；
aThread[1]=CreateThread（NULL，0，（LPTHREAD\u START\u例程）Consumer，NULL，0，&ThreadID）；
返回0；
}
int main（）{
createthreads（）；
SetEvent（hEvent1）；
}

实现此任务的方法有很多种，一种可能是-需要使用事件对-2个事件

struct EventPair 
{
    HANDLE hLowEvent, hHighEvent;

    ~EventPair()
    {
        if (hHighEvent) CloseHandle(hHighEvent);
        if (hLowEvent) CloseHandle(hLowEvent);
    }

    EventPair()
    {
        hLowEvent = 0, hHighEvent = 0;
    }

    DWORD Create()
    {
        return (hLowEvent = CreateEvent(NULL, FALSE, FALSE, NULL)) &&
            (hHighEvent = CreateEvent(NULL, FALSE, FALSE, NULL)) ? NOERROR : GetLastError();
    }
};

struct SharedData : EventPair 
{
    int _x;
    bool _quit;

    SharedData()
    {
        _x = 0;
        _quit = false;
    }

    static DWORD WINAPI _Producer(void* This)
    {
        reinterpret_cast<SharedData*>(This)->Producer();
        ExitThread(0);
    }

    void Producer()
    {
        for (int i = 0; ; )
        {
            _x = i++;
            if (i == 100)
            {
                _quit = true;
            }
            SetEvent(hLowEvent);
            if (_quit)
            {
                return;
            }
            WaitForSingleObject(hHighEvent, INFINITE);
        }
    }

    static DWORD WINAPI _Consumer(void* This)
    {
        reinterpret_cast<SharedData*>(This)->Consumer();
        ExitThread(0);
    }

    void Consumer()
    {
        for(;;) 
        {
            WaitForSingleObject(hLowEvent, INFINITE);
            DbgPrint("%u\n", _x);
            if (_quit)
            {
                return;
            }
            SetEvent(hHighEvent);
        }
    }
};

void testPC()
{
    SharedData sd;
    if (!sd.Create())
    {
        HANDLE hThreads[2] = {};
        if (hThreads[0] = CreateThread(0, 0, SharedData::_Producer, &sd, 0, 0))
        {
            if (hThreads[1] = CreateThread(0, 0, SharedData::_Consumer, &sd, 0, 0))
            {
                WaitForMultipleObjects(2, hThreads, TRUE, INFINITE);
                CloseHandle(hThreads[1]);
            }
            else
            {
                sd._quit = true;
                SetEvent(sd.hHighEvent);
                WaitForSingleObject(hThreads[0], INFINITE);
            }
        }
        CloseHandle(hThreads[0]);
    }
}

struct事件对
{
处理hLowEvent、hHighEvent；
~EventPair（）
{
如果（hHighEvent）关闭手柄（hHighEvent）；
如果（HLOWVENT）关闭手柄（HLOWVENT）；
}
EventPair（）
{
hLowEvent=0，hHighEvent=0；
}
DWORD Create（）
{
返回（hLowEvent=CreateEvent（NULL，FALSE，FALSE，NULL））&&
（hHighEvent=CreateEvent（NULL，FALSE，FALSE，NULL））？无错误：GetLastError（）；
}
};
结构SharedData:EventPair
{
int_x；
布尔!；
SharedData（）
{
_x=0；
_退出=错误；
}
静态DWORD WINAPI_生产者（无效*此）
{
重新解释（这个）->Producer（）；
退出线程（0）；
}
无效生产者（）
{
对于（int i=0；；）
{
_x=i++；
如果（i==100）
{
_退出=真；
}
SetEvent（hLowEvent）；
如果（退出）
{
返回；
}
WaitForSingleObject（hHighEvent，无限）；
}
}
静态DWORD WINAPI_使用者（无效*此）
{
重新解释（此）->Consumer（）；
退出线程（0）；
}
无效消费者（）
{
对于（；；）
{
WaitForSingleObject（hLowEvent，无限）；
DbgPrint（“%u\n”，_x）；
如果（退出）
{
返回；
}
SetEvent（hHighEvent）；
}
}
};
void testPC（）
{
共享数据sd；
如果（！sd.Create（））
{
句柄hThreads[2]={}；
if（hThreads[0]=CreateThread（0,0，SharedData:：_Producer，&sd，0,0））
{
if（hThreads[1]=CreateThread（0,0，SharedData:：u Consumer，&sd，0,0））
{
WaitForMultipleObjects（2，hThreads，TRUE，无限）；
CloseHandle（hThreads[1]）；
}
其他的
{
sd.\u quit=true；
SetEvent（sd.hHighEvent）；
WaitForSingleObject（hThreads[0]，无限）；
}
}
CloseHandle（hThreads[0]）；
}
}

对于此类代码，需要使用2个事件。我认为，对生产者线程和消费者线程使用1个事件将导致本博客描述的痛苦

createthreads必须返回一个值

-并且必须是u stdcall，带有一个参数）两个线程都从WaitForSingleObject开始-在这种情况下都挂起。需要先设置一个事件吗call@RbMm是的，你需要的就是这个@Fsdfdsg你很好！使用信号量而不是事件将支持多个生产者和多个消费者