Window线程安全与线程控制函数

r囧r小猫 2023-02-19 14:25 17阅读 0赞

# **一. 线程安全问题** #

多线程同时访问全局变量：一个线程**取值**后失去CPU另一个线程**取值**后也失去CPU，此时它们保存的就是相同的值。也是是说，比如两个线程再次对全区变量做++操作时变量只会被修改为同样的值。

# 二. 临界区(线程锁) #

### 一. 临界区 ###

临界区：Critical Section (Critical：临界的、关键的)

**1、创建CRITICAL\_SECTION：**

CRITICAL\_SECTION cs;  
  
**2、在使用前进行初始化**

InitializeCriticalSection(&cs);  
  
**3、在函数中使用:**   
  
DWORD WINAPI 线程A(PVOID pvParam) \{  
EnterCriticalSection(&cs);  
//对全局遍历X的操作  
LeaveCriticalSection(&cs);  
return(0);  
\}  
DWORD WINAPI 线程B(PVOID pvParam) \{  
EnterCriticalSection(&g\_cs);  
//对全局遍历X的操作  
LeaveCriticalSection(&g\_cs);  
return(0);  
\}  
  
**4、删除CRITICAL\_SECTION**

VOID DeleteCriticalSection(PCRITICAL\_SECTION pcs);

**临界区结构体：**

> typedef struct \_RTL\_CRITICAL\_SECTION \{  
> PRTL\_CRITICAL\_SECTION\_DEBUG DebugInfo;  
>  **LONG LockCount;  
> LONG RecursionCount;  
> HANDLE OwningThread;**   
> HANDLE LockSemaphore;  
> DWORD SpinCount;  
> \} RTL\_CRITICAL\_SECTION, \*PRTL\_CRITICAL\_SECTION;  
>   
> **LockCount:**  
> 它被初始化为数值 -1  
> 此数值等于或大于 0 时，表示此临界区被占用  
>   
> 等待获得临界区的线程数：LockCount - (RecursionCount -1)  
>   
> **RecursionCount:**  
> 此字段包含所有者线程已经获得该临界区的次数  
>   
> **OwningThread:**  
> 此字段包含当前占用此临界区的线程的线程标识符  
> 此线程 ID 与GetCurrentThreadId 所返回的 ID 相同  
>

**注意：**

**1. 只对可能产生安全问题的最小单元进行加锁，否则会降低运行效率。**

**2. 一般有几个资源就定义几把锁。**

### **线程死锁(哲学家就餐问题的简化版)：** ###

死锁造成的原因很简单，1. 嵌套加锁 2. 加锁顺序不一致。

这样就有可能线程1先拿到资源A，线程2又拿到资源B，而且此时都需要对方的资源才能执行完毕，这样就出现了死锁。解决方案也就是避免上面的两条原因就好了。

#define _CRT_SECURE_NO_WARNINGS
    #include <iostream>
    #include <locale.h>
    #include <Windows.h>
    using namespace std;
    HANDLE hThread;
    CRITICAL_SECTION cs;
    CRITICAL_SECTION g_cs;
    int number1 = 0;
    int number2 = 0;
    
    DWORD WINAPI ThreadProc1(LPVOID a)
    {
    	while (1) {
    		EnterCriticalSection(&g_cs);
    		EnterCriticalSection(&cs);
    		cout << ++number1  << "----------" << ++number2 << endl;
    		LeaveCriticalSection(&cs);
    		LeaveCriticalSection(&g_cs);
    	}
    	DeleteCriticalSection(&cs);
    	return 0;
    }
    DWORD WINAPI ThreadProc2(LPVOID a)
    {
    	while (1) {
    		EnterCriticalSection(&cs);
    		EnterCriticalSection(&g_cs);
    		cout << ++number2 << "----------" << ++number1 << endl;
    		LeaveCriticalSection(&g_cs);
    		LeaveCriticalSection(&cs);
    	}
    	DeleteCriticalSection(&g_cs);
    	return 0;
    }
    
    
    int main(int argc, char *argv[])
    {
    	int a = 10;
    	int b = 20;
    	HANDLE hThread1 = ::CreateThread(NULL, 0, ThreadProc1, &a, 0, NULL);
    	HANDLE hThread2 = hThread = ::CreateThread(NULL, 0, ThreadProc2, &b, 0, NULL);
    	InitializeCriticalSection(&cs);
    	InitializeCriticalSection(&g_cs);
    	CloseHandle(hThread1);
    	CloseHandle(hThread2);
    
    	while (1);
    
    	system("pause");
    	return 0;
    }

# 三. 互斥体 #

先来看来个等待函数：

### **一. 等待一个对象**  ###

**1. 功能：等待函数可使线程自愿进入等待状态，直到一个特定的内核对象变为已通知状态为止.**

hHandle：内核对象句柄，可以是进程也可以是线程。

dwMilliseconds：等待时间，单位是毫秒 INFINITE(-1)一直等待。

2. 返回值：  
WAIT\_OBJECT\_0(0) 等待对象变为已通知  
WAIT\_TIMEOUT(0x102) 超时

3. 已通知与未通知：

1、内核对象中的每种对象都可以说是处于已通知或未通知的状态之中。  
2、当线程**正在运行**的时候，线程内核对象处于未通知状态。  
3、当线程终止运行的时候，它就变为已通知状态。  
4、在内核中就是个BOOL值，运行时FALSE 结束TRUE

DWORD WaitForSingleObject(			
      HANDLE hHandle,        // handle to object			
      DWORD dwMilliseconds   // time-out interval			
    );

**注意：**此函数在传入句柄是**线程或进程**的时候，函数执行完，不会将已通知状态改为未通知状态。但是对于其他内核对象不是如此，所以避免多次调用以使用终止的内核对象。

### **二. 等待多个对象**  ###

1. 字段：

1、nCount：要查看内核对象的数量  
2、lpHandles：内核对象数组  
3、bWaitAll：等到类型 TRUE 等到所有变为已通知 FALSE 只要有一个变为已通知  
4、dwMilliseconds：超时时间，INFINITE一直等待

2. 返回值：

bWaitAll为TRUE时，返回WAIT\_OBJECT\_0(0) 代码所以内核对象都变成已通知  
bWaitAll为FALSE时，返回最先变成已通知的内核对象在数组中的索引  
WAIT\_TIMEOUT(0x102) 超时

DWORD WaitForMultipleObjects(			
      DWORD nCount,             // number of handles in array			
      CONST HANDLE *lpHandles,  // object-handle array			
      BOOL bWaitAll,            // wait option			
      DWORD dwMilliseconds      // time-out interval			
    );

### **三. 互斥体** ###

//进程一：
    	HANDLE g_hMutex = CreateMutex(NULL,FALSE, "XYZ");
    	
    	//进程二：
    	HANDLE g_hMutex = OpenMutex(MUTEX_ALL_ACCESS,FALSE, "XYZ"); //打开形式 是否希望被继承 互斥体名字
    	WaitForSingleObject(g_hMutex,INFINITE);
    	//逻辑代码
    	ReleaseMutex(g_hMutex);
    	
    	//进程三：
    	HANDLE g_hMutex = OpenMutex(MUTEX_ALL_ACCESS,FALSE, "XYZ");
    	WaitForSingleObject(g_hMutex,INFINITE);
    	//逻辑代码
    	ReleaseMutex(g_hMutex);

**LPSECURITY\_ATTRIBUTES(安全 参数)这是互斥体第一个参数类型，一般可以通过有没有此类型判断是不是内核对象。**

> 互斥体与临界区的区别：
> 
> 1、临界区只能用于单个进程间的线程控制。
> 
> 2、互斥体可以设定等待超时，但临界区不能。
> 
> 3、线程意外终结时，Mutex可以避免无限等待。
> 
> 4、Mutex效率没有临界区高。

**互斥体的效率是低于临界区的**，因为互斥体是内核对象，需要用户态和内核态的切换。

# 四. 事件 #

### **一. 内核对象：** ###

进程、线程、文件、文件映射、事件、互斥体等等都是内核对象。创建内核对象的函数都要求设置一个安全参数(**LPSECURITY\_ATTRIBUTES**)，一般传入NULL即可。

### **二. 事件** ###

1. 事件对象的创建：

> HANDLE CreateEvent(  
> LPSECURITY\_ATTRIBUTES lpEventAttributes, // 安全属性 NULL时为系统默认  
> BOOL bManualReset, // TRUE 通过调用ResetEvent将事件对象标记为未通知  
>  **TRUE：需要手动改，在使用多线程的时候不改就可以让其他线程也wait到**  
>  **FALSE：WaitFor之后会自动改为未通知状态**  
> BOOL bInitialState, **// 在创建时：TRUE 已通知状态 FALSE未通知状态**  
> LPCTSTR lpName // 对象名称 以NULL结尾的字符串：希望在跨进程时得到则添加名字，否则不添加。  
> );  
> **返回的是指针的指针**，不能直接访问内核，安全。

2. 事件对象的控制

> BOOL SetEvent(HANDLE hEvent); //将对象设置为已通知  
> Resetevent //设置为未通知

3、关闭时间对象句柄

> CloseHandle();  
> 关闭句柄后内核对象未必消失，只是让内核对象的计数器减一，需要create和open的引用计数共计为0时才会销毁。

**线程同步：线程互斥，而且还要按照次序对数据进行操作。**

使用临界区并添加flag的方式可以实现。但是这样也会占用CPU时间片，影响效率，互斥体也是如此。线程同步可以依靠事件来实现：  
1. CreateEvent的第二个参数设置为修改，即False。  
2. 生产者线程第三个参数为true能够被wait，消费者线程为false。  
3. 生产者线程先执行生产+1，后将消费者线程设置为活跃；因为第二参数为False，所以生产者线程改为通知状态。  
4. 消费者线程消费-1，后将设置生产者线程执行。

就这样，生产者线程先执行，然后未通知，设置对方执行(通知)。**这就是生产消费者模型。**

#define _CRT_SECURE_NO_WARNINGS
    #include <iostream>
    #include <locale.h>
    #include <Windows.h>
    using namespace std;
    //事件和临界区		
    HANDLE g_hSet, g_hClear;
    int g_Max = 10;
    int g_Number = 0;
    
    //生产者线程函数  		
    DWORD WINAPI ThreadProduct(LPVOID pM)
    {
    	for (int i = 0; i < g_Max; i++)
    	{
    		WaitForSingleObject(g_hSet, INFINITE);
    		g_Number = 1;
    		DWORD id = GetCurrentThreadId();
    		printf("生产者%d将数据%d放入缓冲区\n", id, g_Number);
    		SetEvent(g_hClear);
    	}
    	return 0;
    }
    //消费者线程函数		
    DWORD WINAPI ThreadConsumer(LPVOID pM)
    {
    	for (int i = 0; i < g_Max; i++)
    	{
    		WaitForSingleObject(g_hClear, INFINITE);
    		g_Number = 0;
    		DWORD id = GetCurrentThreadId();
    		printf("----消费者%d将数据%d放入缓冲区\n", id, g_Number);
    		SetEvent(g_hSet);
    	}
    	return 0;
    }
    
    int main(int argc, char* argv[])
    {
    
    	HANDLE hThread[2];
    
    	g_hSet = CreateEvent(NULL, FALSE, TRUE, NULL);
    	g_hClear = CreateEvent(NULL, FALSE, FALSE, NULL);
    
    	hThread[0] = ::CreateThread(NULL, 0, ThreadProduct, NULL, 0, NULL);
    	hThread[1] = ::CreateThread(NULL, 0, ThreadConsumer, NULL, 0, NULL);
    
    	WaitForMultipleObjects(2, hThread, TRUE, INFINITE);
    	CloseHandle(hThread[0]);
    	CloseHandle(hThread[1]);
    
    	//销毁 	
    	CloseHandle(g_hSet);
    	CloseHandle(g_hClear);
    
    	return 0;
    }

# 五. 信号量 #

HANDLE CreateSemaphore(  LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, // SD
      LONG lInitialCount,                          // initial count 最大并发数
      LONG lMaximumCount,                          // maximum count 线程总数
      LPCTSTR lpName                               // object name Semaphore的名字
    );

创建 递减计数 递增计数 销毁

CreateSemaphore WaitForSingleObject ReleaseSemaphore CloseHandle

**相对于事件，信号量可以用于相当复杂的线程同步控制。**

#define _CRT_SECURE_NO_WARNINGS
    #include <iostream>
    #include <locale.h>
    #include <Windows.h>
    using namespace std;
    HANDLE hSemaphore;
    DWORD WINAPI ThreadProduct1(LPVOID lpParameter) {
    	while (1) {
    		WaitForSingleObject(hSemaphore, INFINITE);
    		cout << "ThreadProduct1" << endl;
    		Sleep(500);
    		ReleaseSemaphore(hSemaphore, 1, NULL);
    	}
    	return 0;
    }
    DWORD WINAPI ThreadProduct2(LPVOID lpParameter) {
    	while (1) {
    		WaitForSingleObject(hSemaphore, INFINITE);
    		cout << "ThreadProduct2" << endl;
    		Sleep(500);
    		ReleaseSemaphore(hSemaphore, 1, NULL);
    	}
    	return 0;
    }
    DWORD WINAPI ThreadProduct3(LPVOID lpParameter) {
    	while (1) {
    		WaitForSingleObject(hSemaphore, INFINITE);
    		cout << "ThreadProduct3" << endl;
    		Sleep(500);
    		ReleaseSemaphore(hSemaphore, 1, NULL);
    	}
    	return 0;
    }
    int main(int argc, char* argv[])
    {
    	hSemaphore = CreateSemaphore(NULL, 0, 3, NULL);
    	
    	HANDLE hThread[3];
    	hThread[0] = ::CreateThread(NULL, 0, ThreadProduct1, NULL, 0, NULL);
    	hThread[1] = ::CreateThread(NULL, 0, ThreadProduct2, NULL, 0, NULL);
    	hThread[2] = ::CreateThread(NULL, 0, ThreadProduct3, NULL, 0, NULL);
    	
    	ReleaseSemaphore(hSemaphore, 1, NULL);
    	WaitForMultipleObjects(3, hThread, TRUE, INFINITE);
    	
    	CloseHandle(hThread[0]);
    	CloseHandle(hThread[1]);
    	CloseHandle(hThread[2]);
    	CloseHandle(hSemaphore);
    
    	system("pause");
    	return 0;
    }