标签: waitformultipleobjects

我正在研究一个使用互斥锁来保护全局双精度的例子,但是我得到了错误 -

Lab7.exe中0x77b6308e处的未处理异常:0xC0000005:访问冲突写入位置0x00000068.

我认为这与获得分数有关？(全球双倍)

#include <windows.h>
#include <iostream>   
#include <process.h>

double score = 0.0; 


HANDLE threads[10];     

CRITICAL_SECTION score_mutex; 


unsigned int __stdcall MyThread(void *data)
{
    EnterCriticalSection(&score_mutex);
    score = score + 1.0; 
    LeaveCriticalSection(&score_mutex); 

    return 0;
}

int main()
{
    InitializeCriticalSection(&score_mutex); 

    for (int loop = 0; loop < 10; loop++)
    {

        threads[loop] = (HANDLE) _beginthreadex(NULL, 0, MyThread, NULL, 0, NULL); 
    }

    WaitForMultipleObjects(10, threads, 0, INFINITE); 

    DeleteCriticalSection(&score_mutex); 

    std::cout << score; 

    while(true);

}

更新:

在将循环设置为1000而不是10来解决问题之后,错误仍然存​​在,但是当我注释掉引用互斥锁的代码时,错误没有发生.

CRITICAL_SECTION score_mutex; 
EnterCriticalSection(&score_mutex); 
LeaveCriticalSection(&score_mutex); 
InitializeCriticalSection(&score_mutex); 
DeleteCriticalSection(&score_mutex); 

更新2

线程按照惯例返回0(这是一个漫长的一周!)

我尝试在互斥量相关的代码中添加,并且程序将编译并运行正常(除了竞争条件问题与双重当然)与CRITICAL_SECTION,InitializeCriticalSection和DeleteCriticalSection都重新加入.问题似乎与EnterCriticalSection或LeaveCriticalSection,因为我添加它时错误再次出现.

我有

 var H: array of THandle;

然后在一个循环中创建多个线程，并将线程句柄分配给 H 的元素，然后等待它们。将@H[0] 作为第二个参数传递给下面的 WFMO 有效。

WaitForMultipleObjects(Length(H), @H[0], True, INFINITE) <-- Works

但是传递@H 如下失败，WAIT_FAILED。GetLastError 返回“无效句柄”。

WaitForMultipleObjects(Length(H), @H, True, INFINITE)  <--- Fails.

为什么@H 与@H[0] 不同？

由于一些人有文档的不同的解释,我想澄清一劳永逸的所有返回值WaitForMultipleObjects的时

1. bWaitAll = TRUE.
2. 所有手柄都发出信号

根据文件:
返回值
WAIT_OBJECT_0到(WAIT_OBJECT_0 + nCount- 1)
如果bWaitAll为TRUE,则返回值表示发出所有指定对象的状态.

题

假设我已经传递了5个句柄来执行此功能并且所有这些句柄都被发出信号,是返回值WAIT_OBJECT_0吗？

注意

我正在尝试以编程方式验证WaitForMultipleObjects成功.

DWORD dwWaitForMultipleObjectsRes = WaitForMultipleObjects(dwOpenProcessCount, handles, TRUE, m_dwWaitTimeForProcToBeKilled);
if (dwWaitForMultipleObjectsRes != WAIT_OBJECT_0)
   // failed?

我想验证条件的正确性.

我有一个HANDLE列表,由许多不同的IO设备控制.什么是(性能)差异:

1. 在所有这些句柄上调用WaitForMultipleObjects
2. 在所有这些句柄周围的boost :: windows :: basic_handle上的async_read

WaitForMultipleObjects O(n)时间是否与n的句柄数量复杂？
你可以在Windows :: basic_handle上以某种方式调用async_read吗？或者这个假设是错的？
如果我在多个线程中调用同一IO设备上运行,那么这些线程之间的处理调用是否会平衡？这将是使用asio的主要好处.

我希望以随机顺序从0到4得到数字,但相反,我有一些不同步的混乱

我做错了什么？

#include <iostream>
#include <windows.h>
#include <process.h>

using namespace std;

void addQuery(void *v );

HANDLE ghMutex;

int main()
{
    HANDLE hs[5];
    ghMutex = CreateMutex( NULL, FALSE, NULL);         
    for(int i=0; i<5; ++i)
    {
        hs[i] = (HANDLE)_beginthread(addQuery, 0, (void *)&i);
        if (hs[i] == NULL) 
        {
            printf("error\n"); return -1;
        }
    }

    printf("WaitForMultipleObjects return: %d error: %d\n",
         (DWORD)WaitForMultipleObjects(5, hs, TRUE, INFINITE), GetLastError());


    return 0;
}

void addQuery(void *v )
{
    int t = *((int*)v);
    WaitForSingleObject(ghMutex, INFINITE);

    cout << t << endl;

    ReleaseMutex(ghMutex);
    _endthread(); …