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

5 阅读 0 评论 0 点赞

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)
#endif


class 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);
}

本站资源均来自互联网，仅供研究学习，禁止违法使用和商用，产生法律纠纷本站概不负责！如果侵犯了您的权益请与我们联系！

转载请注明出处：免费源码网-免费的源码资源网站 » Windows多线程编程互斥量和临界区使用

点赞(0) 打赏

本文分类：文章资讯
本文标签：Windows多线程编程互斥量和临界区使用
浏览次数：5 次浏览
本文链接：https://freeymw.com/article/32331.html

评论列表共有 0 条评论

暂无评论

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