Windows线程同步详解

Posted 2020-10-27

线程同步问题

在多线程编程中，极容易产生错误。造成错误的原因：两个或多个线程同时访问了共有的资源（比如全局变量，句柄，对空间等），造成资源在不同线程修改时出现不一致。多个线程对于资源的访问要按照一定的先后顺序，但是未按照预想的顺序来，就会导致程序出现意想不到的错误。
问题实例：（环境：vs2015 控制台程序)

#include<Windows.h>
#include<stdio.h>
int g_nNum = 0;
DWORD WINAPI ThreadProc(LPVOID lParam)
{
for (int i = 0; i < 10000; i++)
{
g_nNum++;
}
printf("%d", g_nNum);
return 0;
}
int main()
{
//创建线程1
HANDLE hThread1 = CreateThread(NULL, NULL, ThreadProc, NULL, NULL, NULL);
//创建线程2
HANDLE HThread2 = CreateThread(NULL, NULL, ThreadProc, NULL, NULL, NULL);
WaitForSingleObject(hThread1, INFINITE); //线程1执行完毕后返回
WaitForSingleObject(HThread2, INFINITE); //线程2执行完毕后返回
printf("%d\n", g_nNum);
return 0;
}

第一次执行结果：
11789
17876
17876
第二次执行结果：
20000
15844
20000
按照预期，g_nNum在两个线程中应该各自自增10000，而实际上，g_nNum的值确是不确定的。
首先来看一下自增这个简单的操纵在汇编层的代码：

00AE1419 mov eax,dword ptr ds [00AE8134h]
00AE141E add eax,1
00AE1421 mov dword ptr ds:[00AE8134h],eax

两个线程同时执行g_nNum++这个操作，有可能线程1执行了add eax，还没有将将自增的结果写入，线程2又开始执行，当线程1再执行的时候，线程2的执行就相当于已经无用。因为线程的调度是不可控的，所以我们不能预知最后的结果。

解决方案：**

1.原子操作
原子操作是一些比较简单的操作，只能对资源进行简单的加减赋值等。当运用原子操作访问某数据时，其他线程不能在此次操作结束前访问此数据，即不允许两个线程同时操作一个数据，当然，也不允许三个。原子操作就像厕所，只允许一个人进入。
常见的原子操作函数自行百度

int g_nNum = 0;
DWORD WINAPI ThreadProc(LPVOID lParam)
{
for (int i = 0; i < 10000; i++)
{
//原子操作中的自增，其他的原子操作函数自行百度
InterlockedIncrement((unsigned long*)&g_nNum);
}
printf("%d", g_nNum);
return 0;
}
int main()
{
HANDLE hThread1 = CreateThread(NULL, NULL, ThreadProc, NULL, NULL, NULL);
HANDLE HThread2 = CreateThread(NULL, NULL, ThreadProc, NULL, NULL, NULL);
WaitForSingleObject(hThread1, INFINITE);
WaitForSingleObject(HThread2, INFINITE);
printf("%d\n", g_nNum);
return 0;
}

运行结果
10000
20000
20000

2.临界区

原子操作仅能够解决单独的数据（整型变量的基本运算）的线程同步问题，大多数时候，我们想要实现的是对一个代码段的保护，于是便引入了临界区这一概念。临界区通过EnterCriticalSection与LeaveCriticalSection这一对函数，通过这个函数对，就可以实现多个代码保护区。在使用临界区前，需要调用InitiaizeCriticalSection初始化一个临界区，使用完后调用DeleteCriticalSection销毁临界区。

#include <windows.h>
CRITICAL_SECTION cs = {};
int g_nNum = 0;
DWORD WINAPI ThreadProc(LPVOID lParam) {
    // 2. 进入临界区
    // cs有个属性LockSemaphore是不是被锁定
    // 当调用EnterCriticalSection表示临界区被锁定，OwningThread就是该线程
    // 其他调用EnterCriticalSection，会检查和锁定时的线程是否是同一个线程
    // 如果不是，调用Enter的线程就阻塞
    // 如果是，就把锁定计数LockCount+1
    // 有几次Enter就得有几次Leave
    // 但是，不是拥有者线程的人不能主动Leave
    EnterCriticalSection(&cs);
    for (int i = 0; i < 100000; i++)
    {
        g_nNum++;
    }
    printf("%d\n", g_nNum);
    // 3. 离开临界区
    // 万一，还没有调用Leave，该线程就崩溃了，或死循环了..
    // 外面等待的人就永远等待
    // 临界区不是内核对象， 不能跨进程同步
    LeaveCriticalSection(&cs);
    return 0;
}

int main()
{
    // 1. 初始化临界区
    InitializeCriticalSection(&cs);
    HANDLE hThread1 = CreateThread(NULL, NULL, ThreadProc, NULL, NULL, NULL);
    HANDLE hThread2 = CreateThread(NULL, NULL, ThreadProc, NULL, NULL, NULL);
    WaitForSingleObject(hThread1, INFINITE);
    WaitForSingleObject(hThread2, INFINITE);
    printf("%d\n", g_nNum);
    // 4. 销毁临界区
    DeleteCriticalSection(&cs);
    return 0;
}

3.互斥体

临界区有很多解决不了的问题，因为临界区在一个进程中有效，无法在多进程的情况下进行同步。并且，如果一个线程进入到临界区，结果这个线程由于某些原因奔溃了，即无法执LeaveCriticalSection（），那么其他线程将无法再进入临界区，程序奔溃。而互斥体则可以解决这些问题。
首先，互斥体是一个内核对象。（因此互斥体拥有内核对象的一切属性）它有两个状态，激发态和非激发态；它有一个概念叫做线程拥有权，与临界区类似；等待函数等待互斥体的副作用，将互斥体的拥有者设置为本线程，然后将互斥体的状态设置为非激发态。
主要函数：CreateMutex（）；WaitForSingleObject（）；ReleaseMutex（）；函数用法自行百度。
当一个线程A调用WaitForSingleObject函数时，WaitForSingleObject会立即返回，将并将互斥体设为非激发态，互斥体被锁住，此线程获得拥有权。之后，任何调用WaitForSingleObject的线程无法获得所有权，必须等待互斥体。当线程A调用ReleaseMutex时，互斥体被解锁，此时互斥体又被设置为激发态，并会从等待它的线程中随机选一个，重复前面的过程。互斥体一次只能被一个线程拥有，在WaitXXXX与ReleaseMutex之间的代码被保护起来，这一点与临界区类似，只不过互斥体是一个内核对象，可以进行多进程同步。

#include <windows.h>
#include<stdio.h>
HANDLE hMutex = 0;
int g_nNum = 0;
// 临界区和互斥体比较
// 1. 互斥体是个内核对象，可以跨进程同步,临界区不行
// 2. 当他们的拥有者线程都崩溃的时候，互斥体可以被系统释放，变为有信号，其他的等待函数可以正常返回
// 临界区不行,如果都是假死(死循环，无响应)，他们都会死锁
// 3. 临界区不是内核对象，所以访问速度比互斥体快
DWORD WINAPI ThreadProc(LPVOID lParam) {
    // 等待某个内核对象，有信号就返回，无信号就一直等待
    // 返回时把等待的对象变为无信号状态
    WaitForSingleObject(hMutex, INFINITE);
    for (int i = 0; i < 100000; i++)
    {
        g_nNum++;
    }
    printf("%d\n", g_nNum);
    // 把互斥体变为有信号状态
    ReleaseMutex(hMutex);
    return 0;
}

int main()
{
    // 1. 创建一个互斥体
    hMutex = CreateMutex(
        NULL,
        FALSE,// 是否创建时就被当先线程拥有
        NULL);// 互斥体名称
    HANDLE hThread1 = CreateThread(NULL, NULL, ThreadProc, NULL, NULL, NULL);
    HANDLE hThread2 = CreateThread(NULL, NULL, ThreadProc, NULL, NULL, NULL);
    WaitForSingleObject(hThread1, INFINITE);
    WaitForSingleObject(hThread2, INFINITE);
    printf("%d\n", g_nNum);
    return 0;
}

4.信号量

信号量与互斥体类似。不过信号量中引入了信号数量的概念。如果说互斥体是家里厕所，在一个时间点只能一个人使用，那信号量就是公共厕所，可以多个人同时使用，但是仍有上限。这个上限数量即最大信号数量。
主要函数：CreateSemaphore（）；OpenSemaphore（）；ReleaseSemaphore（）；WaitForSingleObject（）； 函数用法自行百度
当有线程调用了WaitForSingleObject（）；当前信号量减一，再有线程调用，再减一。为0时，即信号量被锁住，再有线程调用WaitForSingleObject时，将被阻塞。

#include <windows.h>
#include <stdio.h>
HANDLE hSemphore;
int g_nNum = 0;
DWORD WINAPI ThreadProc(LPVOID lParam) {
        WaitForSingleObject(hSemphore, INFINITE);
    for (int i = 0; i < 100000; i++)
    {
        g_nNum++;
    }
    printf("%d\n", g_nNum);
    ReleaseSemaphore(hSemphore,
        1,// 释放的信号个数可以大于1，但是释放后的信号个数+之前的不能大于最大值，否则释放失败
        NULL);
    return 0;
}

int main()
{
     hSemphore = CreateSemaphore(
        NULL,
        1,// 初始信号个数
        1,// 最大信号个数，就是允许同时访问保护资源的线程数
        NULL);
    HANDLE hThread1 = CreateThread(NULL, NULL, ThreadProc, NULL, NULL, NULL);
    HANDLE hThread2 = CreateThread(NULL, NULL, ThreadProc, NULL, NULL, NULL);
    WaitForSingleObject(hThread1, INFINITE);
    WaitForSingleObject(hThread2, INFINITE);
    printf("%d\n", g_nNum);
    return 0;
}

5.事件

事件具有较大的权限。可以手动设置事件对象为激发态还是非激发态。创建时间对象的时候，可以设置是自动选择和手动选择。自动选择的事件，等待函数返回时，会自动将其状态设置为非激发态，阻塞其他线程。手动选择的，事件对象状态的控制全靠代码。
主要函数：CreateEventW（）；OpenEventA（）；SetEvent（）；PulseEvent（）；
CloseEvent（）；RoseEvent（）；

#include <windows.h>
#include<stdio.h>
HANDLE hEvent1, hEvent2;
DWORD WINAPI ThreadProcA(LPVOID lParam) {
    for (int i = 0; i < 10; i++){
        WaitForSingleObject(hEvent1, INFINITE);
        printf("A ");
        SetEvent(hEvent2);
    }
    return 0;
}

DWORD WINAPI ThreadProcB(LPVOID lParam) {
    for (int i = 0; i < 10; i++){
        WaitForSingleObject(hEvent2, INFINITE);
        printf("B ");
        SetEvent(hEvent1);
    }
    return 0;
}

int main()
{
    // 事件对象，高度自定义的
     hEvent1 = CreateEvent(
        NULL,
        FALSE,// 自动重置
        TRUE,// 有信号
        NULL);
    // hEvent1自动重置  初始有信号  任何人通过setevent变为有信号 resetevent变为无信号
    // hEvent2自动重置  初始无信号
     hEvent2 = CreateEvent(NULL, FALSE, FALSE, NULL);
    HANDLE hThread1 = CreateThread(NULL, NULL, ThreadProcA, NULL, NULL, NULL);
    HANDLE hThread2 = CreateThread(NULL, NULL, ThreadProcB, NULL, NULL, NULL);
    WaitForSingleObject(hThread1, INFINITE);
    WaitForSingleObject(hThread2, INFINITE);
    return 0;
}