[C++ 网络协议] Windows中的线程同步

news/2023/11/29 6:46:16

1. 用户模式(User mode)和内核模式(Kernal mode)

2. 用户模式的同步(CRITICAL_SECTION)

3. 内核模式同步

3.1 互斥量

3.2 信号量

3.3 事件对象

4. 实现Windows平台的多线程服务器端

1. 用户模式(User mode)和内核模式(Kernal mode)

Windows操作系统的运行方式是“双模式操作”：

用户模式：运行应用程序的基本模式，禁止访问物理设备，而且会限制访问的内存区域。
内核模式：操作系统运行时的模式，不仅不会限制访问的内存区域，而且访问的硬件设备也不会受损。

在应用程序的运行过程中，Windows操作系统会在用户模式和内核模式之间切换。比如说，在Windows中创建线程，虽然创造线程的请求是由应用程序的函数调用来完成的，但是线程是属于操作系统的，所以Windows会先从用户模式切换到内核模式，接着创建线程，分配资源，创建内核对象。

为什么要定义这两种模式？

答：为了提高安全性。因为应用程序在运行时如果发生错误，就可能会破坏操作系统的各种资源。尤其是C/C++可以进行指针运算，就很容易发生这种问题。而用户模式可以保护与操作系统有关的内存区域。所以应用程序在运行时发生错误也只会终止应用程序的运行，而不会终止操作系统。

那这两种模式只有优点吗？

答：不是，频繁的模式切换对系统而言也是一种负担，会影响性能。

2. 用户模式的同步(CRITICAL_SECTION)

用户模式的同步是在用户模式下的同步，这意味着，无需操作系统的帮助而在应用程序级别进行的同步，即无需进行内核模式的切换。

优点：速度快。
缺点：功能上存在局限性。

创建CRITICAL_SECTION对象：

#include<windows.h>void InitializeCriticalSection(
LPCRITICAL_SECTION lpCriticalSection    //传入需要初始化的CRITICAL_SECTION对象//的地址值
);

CRITICAL_SECTION对象，不是内核对象。其只是一把进入临界区的“钥匙”。要进入临界区就提供这一把钥匙，离开临界区就要上交钥匙。

“销毁”CRITICAL_SECTION对象：

#include<windows.h>void DeleteCriticalSection(
LPCRITICAL_SECTION lpCriticalSection    //传入需要销毁的CRITICAL_SECTION对象//的地址值
);

实际上这个函数并不是销毁CRITICAL_SECTION对象，而是销毁CRITICAL_SECTION对象使用过的(或与其相关的)资源。

上锁：

#include<windows.h>void EnterCriticalSection(LPCRITICAL_SECTION lpCriticalSection);

解锁：

#include<windows.h>void LeaveCriticalSection(LPCRITICAL_SECTION lpCriticalSection);

3. 内核模式同步

内核模式的同步就是在内核模式下的同步。意味着都是通过操作系统的帮助下进行的线程同步。可以实现跨进程之间进行线程同步。（因为内核对象属于操作系统，而不属于进程）

优点：比用户模式提供的功能更多、可以指定超时，防止产生死锁
缺点：速度相对用户模式来说较慢

3.1 互斥量

互斥量对象是"auto-reset"模式的内核对象。([C++ 网络协议] Windows平台下的线程里有解释）

创建互斥量：

#include<windows.h>HANDLE CreateMutex(
LPSECURITY_ATTRIBUTES lpMutexAttributes,    //传递安全相关的配置信息，传NULL使用默认安全配置
BOOL bInitialOwner,                         //TRUE，创建的互斥量属于调用该函数的线程，//同时进入non-signaled状态//FALSE，创建处的互斥量对象不属于任何线程，//同时进入signaled状态
LPCTSTR lpName                              //用于命名互斥量对象，传NULL表示无名
);
成功返回创建的互斥量对象句柄
失败返回NULL

bInitialOwner参数：其实就是初始化互斥量的状态的值，为TRUE初始化为non-signaled状态。为FALSE初始化为signaled状态。

销毁互斥量：

#include<windows.h>BOOL CloseHandle(HANDLE hObject);
成功返回TRUE
失败返回FALSE

获取互斥量(上锁)：

#include<windows.h>DWORD WaitForSingleObject(
HANDLE hHandle,            //查看状态的内核对象句柄
DWORD dwMilliseconds       //以1/1000秒为单位指定超时时间，传递INFINITE会阻塞住，//直到内核对象变为signaled状态
);
成功返回事件信息，事件信息：成功进入signaled状态返回WAIT_OBJECT_0,超时返回WAIT_TIMEOUT
失败返回WAIT_FAILED

这个函数就是“单个内核对象状态的查看”。所以可以判断出，线程是否被阻塞，看的是互斥量内核对象的状态。

释放互斥量(解锁)：

#include<windows.h>BOOL ReleaseMutex(HANDLE hMutex);
成功返回TRUE，并使互斥量重新进入signaled状态
失败返回FALSE

例：

HANDLE mutex;
int main()
{mutex=CreateMutex(NULL,FALSE,NULL);    //mutex初始化为signaled状态......
}unsigned WINAPI threadOne(void* arg)
{WaitForSingleObject(mutex,INFINITE);   //mutex为signaled状态，则继续执行//临界区开始                            //因为mutex是auto-reset模式的内核对象，所以mutex会变为non-signaled状态......                                 //临界区结束ReleaseMutex(mutex);                   //释放mutex将其设置为signaled状态  
}unsigned WINAPI threadTwo(void* arg)
{WaitForSingleObject(mutex,INFINITE);  //因为上面线程先执行，mutex变为了non-signaled状态，所以线程阻塞住，等待mutex的释放//临界区开始......//临界区结束ReleaseMutex(mutex);
}

3.2 信号量

创建信号量：

#include<windows.h>HANDLE CreateSemaphore(
LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,    //安全配置信息，默认安全设置传递NULL
LONG lInitialCount,                             //指定信号量的初始值，应>0，且<lMaximumCount
LONG lMaximumCount,                             //信号量的最大值，为1，则是二进制信号量(只能表示0或1)
LPCTSTR lpName                                  //命名信号量对象，传NULL为无名
);
成功返回创建的信号量对象的句柄
失败返回NULL

销毁信号量：（和互斥量是一样的销毁句柄语句）

#include<windows.h>BOOL CloseHandle(HANDLE hObject);
成功返回TRUE
失败返回FALSE

通过信号量，判断线程是否阻塞：

#include<windows.h>DWORD WaitForSingleObject(
HANDLE hHandle,            //查看状态的内核对象句柄
DWORD dwMilliseconds       //以1/1000秒为单位指定超时时间，传递INFINITE会阻塞住，//直到内核对象变为signaled状态
);
成功返回事件信息，事件信息：成功进入signaled状态返回WAIT_OBJECT_0,超时返回WAIT_TIMEOUT
失败返回WAIT_FAILED

这个函数也是“单个内核对象状态的查看”。返回的同时信号量-1。

利用信号量为0时，进入non-signaled状态，大于0时，进入signaled状态，来进行同步。

释放信号量：

#include<windows.h>BOOL ReleaseSemaphore(
HANDLE hSemaphore,        //传递需要释放的信号量
LONG lReleaseCount,       //释放信号量会增加，这个参数指定要增加的值，超过最大值则不增加且返回FALSE
LPLONG lpPreviousCount    //保存修改之前值得变量地址，不需要的话可传NULL
);
成功返回TRUE
失败返回FALSE

例：

HANDLE semOne;
HANDLE semTwo;int main()
{semOne=CreateSemaphore(NULL,0,1,NULL);    //semOne为non-signaled状态semTwo=CreateSemaphore(NULL,1,1,NULL);    //semTwo为signaled状态......
}unsigned WINAPI threadOne(void* arg)
{WaitForSingleObject(semTwo,INFINITE);    //semTwo为signaled状态，继续执行，且semTwo-1变为non-signaled状态//临界区......//临界区ReleaseSemaphore(semOne,1,NULL);        //semOne+1，变为signaled状态
}unsigned WINAPI threadTwo(void* arg)
{WaitForSingleObject(semOne,INFINITE);   //通过上一个线程，semOne为signaled状态，开始执行，且semOne-1，变为non-signaled状态//临界区......//临界区ReleaseSemaphore(semTwo,1,NULL);
}

3.3 事件对象

基于事件对象的线程同步，与前两种同步方式有很大不同，因为事件对象创建时，可以选择是“auto-reset”模式还是“manual-reset”模式。这也是其进行同步的方式。

创建事件对象：

#include<windows.h>HANDLE CreateEvent(
LPSECURITY_ATTRIBUTES lpEventAttributes,    //安全配置信息，默认安全设置传递NULL
BOOL bManualReset,                          //TRUE，创建manual-reset模式的事件对象//FALSE，创建auto-reset模式的事件对象
BOOL bInitialState,                         //TRUE,事件对象初始化为signaled状态//FALSE,事件对象初始化为non-signaled状态
LPCTSTR lpName                              //命名信号量对象，传NULL为无名
);
成功返回创建的事件对象句柄
失败返回NULL

销毁事件对象(销毁句柄语句)：

#include<windows.h>BOOL CloseHandle(HANDLE hObject);
成功返回TRUE
失败返回FALSE

更改事件对象状态：

#include<windows.h>BOOL ResetEvent(HANDLE hEvent);    //将事件对象设置为non-signaled状态
BOOL SetEvent(HANDLE hEvent);      //将事件对象设置为signaled状态
成功返回TRUE
失败返回FALSE

例如：实现两个线程同时退出阻塞状态的情景。

HANDLE event;int main()
{event=CreateEvent(NULL,TRUE,FALSE,NULL);    //将事件对象设置为mamual-reset模式，并初始化为non-signaled状态......SetEvent(event);    //将事件对象设置为singnaled状态......
}unsigned WINAPI threadOne(void* arg)
{WaitForSingleObject(event,INFINITE);    //阻塞，等待事件对象设置为singaled状态//临界区......//临界区
}unsigned WINAPI threadTwo(void* arg)
{WaitForSingleObject(event,INFINITE);    //阻塞，等待事件对象设置为singaled状态//临界区......//临界区
}