Windows多线程编程互斥量和临界区使用

Windows 多线程编程允许程序同时运行多个线程，提高程序的并发性和执行效率。多线程编程中的核心概念包括线程的创建、同步、调度、数据共享和竞争条件等。本文详细介绍了 Windows 多线程编程的关键技术点，并解释如何使用线程同步机制来保证线程安全。

1. 线程基础概念

1.1 线程

线程是操作系统能够独立调度的最小执行单元。一个进程可以包含多个线程，这些线程共享进程的地址空间和资源。多线程编程通过并发执行多个线程，提升程序性能，特别是在 I/O 操作、网络请求或图像处理等任务中。

1.2 进程 vs. 线程

进程：程序在操作系统中的运行实例。每个进程有独立的地址空间和资源。
线程：线程是进程中的轻量级执行单元，多个线程可以共享进程的内存和资源。一个进程至少包含一个主线程，可以派生出多个子线程。

2. 线程的创建与管理

在 Windows 中，创建和管理线程可以通过 WinAPI 提供的多种方法，其中常用的是 CreateThread 和 C++11 提供的标准库线程类。

2.1 使用 CreateThread

这是 WinAPI 中直接用于创建线程的函数，它返回一个线程句柄，用于管理线程。

#include <windows.h>
#include <iostream>// 线程函数
DWORD WINAPI ThreadFunc(LPVOID lpParam) {for (int i = 0; i < 5; i++) {std::cout << "Thread running...\n";Sleep(1000); // 模拟工作，暂停1秒}return 0;
}int main() {HANDLE hThread = CreateThread(NULL,            // 默认安全属性0,               // 默认堆栈大小ThreadFunc,      // 线程函数NULL,            // 参数传递给线程函数0,               // 默认创建标志NULL             // 可选的线程ID);if (hThread == NULL) {std::cout << "Error: Unable to create thread\n";return 1;}// 等待线程结束WaitForSingleObject(hThread, INFINITE);// 关闭线程句柄CloseHandle(hThread);return 0;
}

2.2 使用 C++11 std::thread

现代 C++ 提供了跨平台的 std::thread 类，用来简化线程的创建和管理。

#include <iostream>
#include <thread>void ThreadFunc() {for (int i = 0; i < 5; i++) {std::cout << "Thread running...\n";std::this_thread::sleep_for(std::chrono::seconds(1));  // 模拟工作}
}int main() {std::thread t(ThreadFunc);  // 创建线程t.join();  // 等待线程结束return 0;
}

3. 线程同步

在多线程程序中，多个线程可能会同时访问共享资源（如内存、文件等），如果不加以控制，可能会导致数据竞态条件（Race Condition）。线程同步用于协调线程对共享资源的访问，避免数据冲突。

常用的同步机制包括：

临界区（Critical Section）
互斥量（Mutex）
信号量（Semaphore）
事件（Event）

3.1 临界区（Critical Section）

临界区是一种轻量级的同步机制，仅适用于单进程的线程同步。临界区在同一时间只允许一个线程进入，其他线程必须等待当前线程离开临界区后才能进入。

#include <windows.h>
#include <iostream>CRITICAL_SECTION criticalSection;  // 定义临界区void ThreadFunc() {EnterCriticalSection(&criticalSection);  // 进入临界区std::cout << "Thread ID: " << GetCurrentThreadId() << " is working.\n";LeaveCriticalSection(&criticalSection);  // 离开临界区
}int main() {InitializeCriticalSection(&criticalSection);  // 初始化临界区HANDLE hThread1 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadFunc, NULL, 0, NULL);HANDLE hThread2 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadFunc, NULL, 0, NULL);WaitForSingleObject(hThread1, INFINITE);WaitForSingleObject(hThread2, INFINITE);DeleteCriticalSection(&criticalSection);  // 删除临界区return 0;
}

3.2 互斥量（Mutex）

互斥量可以在多个线程甚至多个进程之间同步访问共享资源。与临界区相比，互斥量开销较大，但功能更强。

#include <windows.h>
#include <iostream>HANDLE hMutex;void ThreadFunc() {WaitForSingleObject(hMutex, INFINITE);  // 获取互斥量std::cout << "Thread ID: " << GetCurrentThreadId() << " is working.\n";ReleaseMutex(hMutex);  // 释放互斥量
}int main() {hMutex = CreateMutex(NULL, FALSE, NULL);  // 创建互斥量HANDLE hThread1 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadFunc, NULL, 0, NULL);HANDLE hThread2 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadFunc, NULL, 0, NULL);WaitForSingleObject(hThread1, INFINITE);WaitForSingleObject(hThread2, INFINITE);CloseHandle(hMutex);  // 关闭互斥量句柄return 0;
}

3.3 信号量（Semaphore）

信号量允许多个线程访问同一资源，信号量内部有一个计数器，控制同时访问的线程数量。当计数器减为 0 时，其他线程必须等待。

#include <windows.h>
#include <iostream>HANDLE hSemaphore;void ThreadFunc() {WaitForSingleObject(hSemaphore, INFINITE);  // 等待信号量std::cout << "Thread ID: " << GetCurrentThreadId() << " is working.\n";ReleaseSemaphore(hSemaphore, 1, NULL);  // 释放信号量
}int main() {hSemaphore = CreateSemaphore(NULL, 2, 2, NULL);  // 最大允许2个线程同时执行HANDLE hThread1 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadFunc, NULL, 0, NULL);HANDLE hThread2 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadFunc, NULL, 0, NULL);HANDLE hThread3 = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ThreadFunc, NULL, 0, NULL);WaitForSingleObject(hThread1, INFINITE);WaitForSingleObject(hThread2, INFINITE);WaitForSingleObject(hThread3, INFINITE);CloseHandle(hSemaphore);return 0;
}

3.4 事件（Event）

事件用于在线程之间传递信号，某个线程可以等待事件的状态（有信号或无信号），然后作出相应动作。事件可以用来实现线程之间的通知机制。

#include <windows.h>
#include <iostream>HANDLE hEvent;DWORD WINAPI ThreadFunc(LPVOID lpParam) {std::cout << "Thread waiting for event...\n";WaitForSingleObject(hEvent, INFINITE);  // 等待事件std::cout << "Thread received event signal!\n";return 0;
}int main() {hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);  // 创建事件HANDLE hThread = CreateThread(NULL, 0, ThreadFunc, NULL, 0, NULL);Sleep(2000);  // 模拟工作SetEvent(hEvent);  // 触发事件WaitForSingleObject(hThread, INFINITE);CloseHandle(hEvent);return 0;
}

4. 线程同步中的问题

4.1 死锁

死锁是指两个或多个线程在等待彼此持有的资源，导致线程永远无法继续执行。避免死锁的方法：

使用一致的锁顺序：所有线程获取锁的顺序要一致。
避免嵌套锁定：尽量避免一个线程在持有一个锁的同时请求另一个锁。

4.2 竞争条件

竞争条件发生在多个线程同时读取或写入共享数据时，由于执行顺序的不确定性，可能导致错误结果。解决方法是使用合适的同步机制（如临界区、互斥量等）来保护共享数据的访问。

5、Window线程和临界封装

1、线程XThread

1、XThread.h

#pragma once#ifdef  XPLATFORM_EXPORTS
#define XPLATFORM_API __declspec(dllexport)
#else
#define XPLATFORM_API __declspec(dllimport)
#endifclass XPLATFORM_API XThread
{
public:XThread();virtual ~XThread();bool Start();virtual void Run() = 0;void Wait();void Suspend();void Resume();
private:unsigned int thId = 0;
};

2、XThread.cpp

#include "XThread.h"
#include <process.h>
#include <Windows.h>XThread::XThread()
{}
XThread::~XThread()
{
}
static void ThreadMain(void *para)
{XThread* th = (XThread*)para;if(th == nullptr) return;th->Run();_endthread();
}
bool XThread::Start()
{thId = _beginthread(ThreadMain, 0, this);return thId <= 0;
}
void XThread::Wait()
{if(thId <= 0) return;WaitForSingleObject((HANDLE)thId, INFINITE);
}
void XThread::Suspend()
{if (thId <= 0) return;SuspendThread((HANDLE)thId);
}
void XThread::Resume()
{if (thId <= 0) return;ResumeThread((HANDLE)thId);
}

2、临界区封装

1、XMutex.h

#pragma once
#ifdef  XPLATFORM_EXPORTS
#define XPLATFORM_API __declspec(dllexport)
#else
#define XPLATFORM_API __declspec(dllimport)
#endif
class XPLATFORM_API XMutex
{
public:XMutex();~XMutex();void Lock();void UnLock();
private:void* section = nullptr;
};

2、XMutex.cpp

#include "XMutex.h"
#include <windows.h>XMutex::XMutex()
{this->section = new CRITICAL_SECTION();if (section == nullptr) return;InitializeCriticalSection((LPCRITICAL_SECTION)this->section);
}XMutex::~XMutex()
{CRITICAL_SECTION *critical_section = (LPCRITICAL_SECTION)this->section;if(critical_section == nullptr) return;delete critical_section;
}void XMutex::Lock()
{if (section == nullptr) return;EnterCriticalSection((LPCRITICAL_SECTION)this->section);
}void XMutex::UnLock()
{if(section == nullptr) return;LeaveCriticalSection((LPCRITICAL_SECTION)this->section);
}