WindowsAPI 查阅笔记：线程、多个线程互同步

已于 2024-08-13 11:04:11 修改
阅读量361 收藏 3
点赞数 6
分类专栏： Windows 编程 文章标签： 笔记 winAPI windows C++
于 2024-08-13 09:42:49 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/orange1710/article/details/141127454
版权

1. 线程的创建

HANDLE CreateThread(
	LPSECURITY_ATTRIBUTES 	lpThreadAttributes, //线程安全属性 
	SIZE_T					dwStackSize,		//线程堆栈大小 
	LPTHREAD_START_ROUTINE 	lpStartAddress,	//重要:  线程函数指针 
	LPVOID 					lpParameter,	//重要:  启动线程函数 
	DWORD 					dwCreationFlags,	//线程安全属性
	LPDWORD 				lpThreadId			//返回 TID 
);//返回新建线程的句柄

1.1 线程函数

要符合接口参数要求

//ThreadProc 函数原型
DWORD WINAPI ThreadProc(
	LPVOID lpParameter
);

1.2 线程句柄与 TID

每一个线程都有一个句柄和一个标识符 (TID)。
TID 是 DWORD 类型，每个线程的 TID 都不同，所以可以用 TID 标识唯一的 线程。

  • 通过 TID 和 OpenThread() 可以获取线程的句柄。
  • 通过 句柄 和 GetThreadId()可以获取线程的TID。
  • GetCurrentThread() 获取本线程句柄。
  • GetCurrentThreadId() 获取本线程 TID。

1.3 创建线程代码

#include <windows.h>
#include <cstdio>

#define MAX_THREADS 5

typedef struct _THREAD_PARAM{
	DWORD i;
	DWORD dwRandom;
	DWORD dwData;
} THREAD_PARAM, *LPTHREAD_PARAM;

/****************
功能：线程函数，将参数打印出来 
****************/ 
DWORD WINAPI ThreadProc(LPVOID lpParam)
{
	//参数数据类型 
	LPTHREAD_PARAM pData;
	pData = (LPTHREAD_PARAM)lpParam;
	
	printf("TID = %u,\tparameters = %u, %u, %u\n",
		GetCurrentThreadId(),
		pData->i,
		pData->dwRandom,
		pData->dwData);
	//释放保存参数的内存（主线程中分配的）
	HeapFree(GetProcessHeap(), 0, pData); 
	return 0;
}

/*********************
功能：创建多个线程 
******************/
int main(int argc, char **argv)
{
	LPTHREAD_PARAM pData;
	DWORD dwThreadId[MAX_THREADS];
	HANDLE hThread[MAX_THREADS];
	int i;
	//创建 MAX_THREADS 个线程 
	for(i = 0 ;i < MAX_THREADS; ++i){
		//为线程函数参数分配内存
		pData = (LPTHREAD_PARAM)HeapAlloc(GetProcessHeap(),
			HEAP_ZERO_MEMORY, sizeof(THREAD_PARAM));
			
		if(pData == NULL){
			printf("HeapAlloc error;\n");
			ExitProcess(2);
		} 
		//设置参数
		pData->i = i;
		pData->dwRandom = rand();
		pData->dwData = 100;
		//创建线程
		hThread[i] = CreateThread(
			NULL,		//默认安全属性
			0,			//默认堆栈大小
			ThreadProc,	//线程函数
			pData,		//参数
			0,			//默认创建标志
			&dwThreadId[i]);//返回TID 
			
		if(hThread[i] == NULL){
			printf("hThread[%d]创建失败!\n",i);
			ExitProcess(i);
		}
		Sleep(10);
	}
	
	//主线程等待其他子线程执行结束
	WaitForMultipleObjects(MAX_THREADS, hThread, TRUE, INFINITE);
	//关闭所有线程的句柄
	for(i = 0; i < MAX_THREADS; ++i){
		CloseHandle(hThread[i]);
	} 
	return 0;
}

代码运行结果：
在这里插入图片描述

2. 线程的挂起、恢复、切换、终止

//schedule.cpp

#include <windows.h>
#include <cstdio>

DWORD WINAPI ThreadProc(LPVOID lpParam)
{
	LPDWORD pData = (LPDWORD)lpParam;
	DWORD i = 0;
	
	for(i = 0; i < 10; ++i){
		Sleep(100);//每 ms 打印一次
		printf("TID = %u,\tparameters = %u\ti = %u\n",
			GetCurrentThreadId(), *pData, i); 
	}
	ExitThread(i);
	return 0;
}
/*********************
功能：线程调度 
*********************/
int main(int argc, char **argv)
{
	DWORD dwData;
	DWORD dwThreadId[2];
	HANDLE hThread[2];
	
	//创建线程
	dwData = 1;
	hThread[0] = CreateThread(
		NULL,0,
		ThreadProc,
		&dwData,
		CREATE_SUSPENDED,	//挂起新建的进程
		&dwThreadId[0] 
	);
	if(hThread[0] == NULL){
		ExitProcess(0); 
	}
	
	//创建线程
	dwData = 2;
	hThread[1] = CreateThread(NULL, 
		0, 
		ThreadProc, 
		&dwData, 
		0,
		&dwThreadId[1]);
	if(hThread[1] == NULL){
		ExitProcess(1);
	} 
	
	//等待 200ms 恢复线程的执行
	Sleep(200);
	ResumeThread(hThread[0]);
	//挂起线程的执行
	SuspendThread(hThread[1]);
	//等待 300 ms 终止线程，恢复线程
	Sleep(300);
	TerminateThread(hThread[0], 0);
	ResumeThread(hThread[1]);
	
	//等待所有线程执行结束
	WaitForMultipleObjects(2, hThread, TRUE, INFINITE);
	//关闭所有线程的句柄
	CloseHandle(hThread[0]);
	CloseHandle(hThread[1]);
	
	return 0;
}

运行结果：
在这里插入图片描述

3. 等待函数

等待函数可以等待同步对象以外，还可以等待其他对象，包括进程和线程。以进程或线程句柄为等待对象就可以了。
以下两个是下面的同步代码中用到的。
在下面代码中用到的时候添加了注释。

3.1 等待函数

//WaitForSingleObject 
//功能是等待单个对象,如果对象被标记，则返回
DWORD WINAPI WaitForSingleObject(
	DANDLE hHandle,
	DWORD dwMilliseconds
);

//WaitForMultipleObjects 
// 功能是等待多个对象，等待的所有对象都设置为标记的 / 有一个设置为标记的 则返回.
DWORD WINAPI WaitForMultipleObjects(
	DWORD nCount,
	const HANDLE *lpHandles,
	BOOL bWaitAll,
	DWORD dwMilliseconds
);

3.2 标记函数

设置标记：

//设置标记
//将事件对象设置为标记
BOOL WINAPI SetEvent(HANDLE hEvent);

重置标记：

//重置标记
//如果事件设置为手工重置，那么需要使用此函数来重置事件
BOOL WINAPI ResetEvent(HANDLE hEvent);

获取事件句柄：

//从事件名中获取事件句柄
HANDLE WINAPI OpenEvent(
	DWORD dwDesiredAccess,
	BOOL bInheritHandle,
	LPCTSTR lpName
);

4. 多个线程互同步

创建三个线程，对一个全局变量进行读操作。
通过三个读事件和写事件控制三个线程，避免在写入数据的时候发生【读事件】。

  1. 主线程创建3个线程，创建【读事件】和【写事件】，并设置为false.
  2. 主线程开始写入数据，之后打开【写事件】，并开始等待【读事件】。
  3. 子线程之前的【写事件】状态是关闭，所以在等待。【写事件】打开后，开始执行打印数据操作。然后打开【读事件】。
  4. 最后关闭子进程。
#include <windows.h>
#include <cstdio>

//常量定义 
#define NUMTHREADS 3
#define BUFFER_SIZE 16
#define FOR_TIMES 5

//全局变量
HANDLE hThread[NUMTHREADS]; 
//写 event 表示写操作是否完成 
HANDLE hWriteEvent[NUMTHREADS];
//读 event 表示读操作是否完成 
HANDLE hReadEvents[NUMTHREADS]; 
//共享内存 
// BYTE lpSharedBuffer[16] = {0};
LPSTR lpSharedBuffer;
DWORD* index;

//函数声明
void MultiEvents(void);
void WriteToBuffer(void);
DWORD WINAPI ThreadFunction(LPVOID lpParam);
/******************
int main(void)
******************/ 
int main(void)
{
	index = (DWORD*)malloc(sizeof(DWORD));
	lpSharedBuffer = (char*)malloc(sizeof(char)*64);
	
	MultiEvents();
	
	free(index);
	free(lpSharedBuffer);
	return 0;
}
/*******************
演示 event 的使用方法 
******************/
void MultiEvents(void)
{
//	HANDLE hThread;
	DWORD i = 0;
	
	*index = i;

	//创建多个线程，读共享内存,主线程写共享内存
	//每个线程都有对应的读写同步事件
	for(i = 0; i < NUMTHREADS; ++i){
		*index = i;
		//每个线程都有一个 event 表示写入操作完成
		hWriteEvent[i] = CreateEvent(
			NULL,		//默认安全属性
			FALSE,		//自动重置
			FALSE,		//初始化为未置位的
			NULL		//未命名 
		);
		//判断是否创建成功
		if(hWriteEvent[i] == NULL){
			printf("CreateEvent failed (%d)\n",GetLastError());
			return ;
		} 
		
		//每个线程都有一个 event 表示读入操作完成
		hReadEvents[i] = CreateEvent(
			NULL,		//默认安全属性
			FALSE,		//自动重置
			FALSE,		//初始化为未置位的
			NULL		//未命名 
		);
		//判断是否创建成功
		if(hReadEvents[i] == NULL){
			printf("CreateEvent failed (%d)\n",GetLastError());
			return ;
		} 
		
		
		//创建线程

		hThread[i] = CreateThread(NULL, 0, 
			ThreadFunction, 
			index, 
			0, NULL
		);
			
		if(hThread[i] == NULL){
			printf("CreateThread failed (%d)\n",GetLastError());
			return ;
		} 
		printf("CreateThread: %d\n",i);

	} 
	WriteToBuffer();
	
	
	//主线程等待其他子线程执行结束
	WaitForMultipleObjects(NUMTHREADS, 
		hThread, TRUE, INFINITE);
	//关闭所有线程的句柄
	for(i = 0; i < NUMTHREADS; ++i){
		CloseHandle(hThread[i]);
		printf("CloseThread:%d\n",i);
	} 
	

	return ;
}

/************************
由主线程调用，向共享内存中写入数据，
等待所有读线程读完后函数返回 
*********************/
void WriteToBuffer(void)
{
	DWORD dwWaitResult, j, i;
	//完成 for_times 次读写
	for(j = 0;j < FOR_TIMES; ++j){
		//写入需要的时间间隔 
		Sleep(rand()%100);
		//写入共享内存
		wsprintf(lpSharedBuffer,"shared %d",j);
		//将线程对应的写 Event 置为 "标志的",表示写操作完成
		//其他线程可以开始读
		for(i = 0; i < NUMTHREADS; ++i){
			if(! SetEvent(hWriteEvent[i])){
				printf("SetEvent failed (%d)\n",GetLastError());
				return ;
			}
		} 
		dwWaitResult = WaitForMultipleObjects(
			NUMTHREADS,		//Event 句柄的个数
			hReadEvents,	//Event句柄数组
			TRUE,			//等到所有的event都被标志
			INFINITE 		//无线等待 
		);
		//判断等待结果
		if(dwWaitResult != WAIT_OBJECT_0){
			printf("Wait errpr (%d)\n",GetLastError());
			ExitProcess(0);
		} 
	} 
	return ;
} 

/*******************
线程函数，读共享内存 
*******************/
DWORD WINAPI ThreadFunction(LPVOID lpParam)
{
	DWORD dwWaitResult;
	LPSTR lpRead[16];
	DWORD j = 0;
	DWORD dwThreadIndex = *(DWORD*)lpParam;
	printf("Hello! dwThreadIndex = %d\n",dwThreadIndex);
	//完成 FOR_TIMES 次读写
	for(; j < FOR_TIMES; ++j)
	{
		//等待写事件置位,表示数据已经写入
		dwWaitResult =  WaitForSingleObject(
			hWriteEvent[dwThreadIndex],	//event 句柄 
			INFINITE					//无限等待 
		);
		
		switch(dwWaitResult)
		{
			case WAIT_OBJECT_0:
					//模拟数据处理需要的时间间隔 
				Sleep(rand()%10);
				CopyMemory(lpRead, lpSharedBuffer, 16);
				break;
				//发生错误
			default:
				printf("wait errpr: %d\n",GetLastError());
				ExitProcess(0);
		}
		//将读 event 置位,表示读操作完成
		if(!SetEvent(hReadEvents[dwThreadIndex])){
			printf("SetEvent failed (%d)\n",GetLastError());
			return 0;
		} 
		//打印读到的内容
		printf("线程 %u\t第 %d 次读, 内容: %s\n",
			dwThreadIndex,j,(LPSTR)lpRead);
	} 
	return 1;
}

运行结果：
在这里插入图片描述

5. C++11 中的互斥

#include <iostream>
#include <thread>
#include <mutex>
#include <windows.h>

std::mutex mtx;	//全局互斥锁
int shared_resource = 0;

void Num1(void){
	for(int i = 0; i < 3; ++i){
		mtx.lock();//锁定互斥锁
		++shared_resource;
		printf("This is AddNum!\n");
		mtx.unlock();//解锁互斥锁 
	}
	return ;
}
void Num2(void){
	for(int i = 0; i < 3; ++i){
		mtx.lock();
		++shared_resource;
		printf("This is PrintNum!\n");
		mtx.unlock();
	}
	return ;
}

int main(void){
	
	std::thread t1(Num1);
	std::thread t2(Num2);
	
	t1.join();
	t2.join();
	
	std::cout <<"Final value of shared_resource: " << shared_resource << std::endl;
	
	return 0;
}

运行结果：
在这里插入图片描述

1710orange
关注
  • 6
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Windows多线程控制台程序
m0_50377559的博客
07-05 2189
学习笔记 Windows多线程控制台程序目的：学习和掌握如何编写Windows多线程控制台程序。通过编写程序，加深对进程和线程关系的理解，掌握多线程程序的执行和编写技巧。设计要求：写一个单进程多线程的Windows控制台程序，该程序在一个进程内建立N个线程来执行指定的任务。N由命令行传递给系统。Win32控制台程序中，主函数的格式如：Void main(int argc,char *argv[])，可以获取命令行参数。通过VC++“工程/设置”的C/C++属性页设置应用程序为“MTD”多线程。利用win32
WINDOWS_API_函数的整理笔记综合.doc
04-15
在Windows API中，这些函数是开发者进行网络操作、消息处理和文件管理的关键工具。下面将分别详细介绍这些领域的关键函数。 1. **网络函数**： - **WNetAddConnection**，**WNetAddConnection2** 和 **...
Windows API笔记（三）线程同步
David
05-29 804
Windows API笔记（一）内核对象 Windows API笔记（二）进程和进程间通信、进程边界 Windows API笔记（三）线程和线程同步、线程局部存储 Windows API笔记（三）线程同步 Windows API笔记（四）win32内存结构 Windows API笔记（五）虚拟内存 Windows API笔记（六）内存映射文件 Windows API笔记（七）堆 Windows A...
C语言：WindowsAPI个人学习笔记（一）
2301_82205515的博客
06-29 1740
每个窗口都有一个且唯一的窗口过程函数，当窗口接收到消息时，系统会调用这个函数来处理消息。五、消息循环是Windows编程中的一个核心概念，它负责处理应用程序中的消息。（学习WindowsAPI的学生是这样的，Windows开发人员只需要专心致志，奋力开发Windows系统就可以了，而看沟槽的缩写的学生要考虑的就很多了 ）2.消息处理：当一个线程接收到消息时，它会从消息队列中取出消息，并将其传递给相应的窗口过程函数（这个函数会检查消息队列中是否有消息，如果有，它会从队列中取出消息，并将其传递给窗口过程函数。
多线程 01：Java 多线程学习导航，线程简介，线程相关概念的整理
默默找寻着，那于世而存的蛛丝马迹。
08-07 847
本文是关于 Java 多线程学习的导航篇，总览了有关多线程学习的几个模块。简单介绍了一些与线程相关的基本概念，便于后续展开多线程的学习。 Java 多线程学习主要模块包括：线程简介；线程实现；线程状态；线程同步；线程通信问题；拓展高级主题。
《C#多线程编程实战》读书笔记
素履独行 | 元培的个人博客
01-13 6423
本文是一篇读书笔记，由《C#多线程编程实战》一书中的内容整理而来，主要梳理了.NET中多线程编程相关的知识脉络，从Thread、ThreadPool、Task、async/await、并发集合、Parallel、PLINQ到Rx及异步I/O等内容，均有所覆盖。为了帮助大家理解本文内容，首先给出博主在阅读该书过程中绘制的思维导图，大家可以根据个人需要针对性的查漏补缺。 线程基础 Tips1
Windows进程与线程学习笔记（六）—— 线程切换
qq_41988448的博客
12-06 1169
Windows进程与线程学习笔记（六）—— 线程切换前言主动切换时钟中断异常处理 前言 一、学习自滴水编程达人中级班课程，官网：https://bcdaren.com 二、海东老师牛逼！ 主动切换 Windows中绝大部分API都调用了SwapContext函数，也就是说，当线程只要调用了API，教室导致线程切换 线程切换时会比较是否属于同一个进程，如果不是，切换Cr3，Cr3换了，进程也就...
39、C++11多线程及其学习笔记
BaoTTing的博客
11-11 1869
一、创建线程
Windows程序设计学习笔记——线程(三)线程注入
weixin_48088263的博客
07-31 1309
本文先介绍了C中的线程创建操作，再介绍了C++标准库的多线程操作，最后着重介绍了远程线程注入技术，远程线程注入就是在其他进程中创建我们的线程，我们的线程会把我们的dll载入到注入进程中，这便是远程线程注入技术，接着介绍了相关api，最后介绍了线程注入的相应步骤...
MFC学习笔记——多线程学习
xzsfg6825的博客
05-07 2579
一、多线程编程思想1、 Windows线程（1）在Windows平台上，从根本上可以利用CPU执行代码的最小实体就是线程（2）首先从内核角度看，线程是一个内核对象，系统用它来存储一些关于线程的统计信息等（比如运行时间）（3）其次从编程的角度看，线程是一堆寄存器状态以及线程栈的一个结构体对象，本质上可以理解为一个函数调用器（寄存器状态用于控制CPU执行，栈用于存储局部变量和函数调用参数及函数返回地址...
Java高并发核心编程(JUC)—线程详细笔记
Cheney的博客
05-22 852
超详细Java线程详情笔记！自己整理，排版简介！
Win32多线程程序设计_WIN32多线程程序设计学习笔记.zip
04-17
总之，Win32多线程程序设计涉及到线程创建、同步、通信、管理等多个方面，理解并熟练运用这些概念和技术，是构建高效并发程序的关键。在实际开发中，要时刻关注线程安全，避免出现未预期的行为，同时合理调度和管理...
WindowsAPI笔记
11-12
Windows API支持多线程，`CreateThread()`函数创建新线程，`WaitForSingleObject()`和`WaitForMultipleObjects()`用于线程同步，`ExitThread()`结束线程。 九、系统调用 系统调用如`GetSystemTime()`获取系统时间，...
Windows API开发详解：函数、接口、编程实例
10-22
在IT领域，Windows API（应用程序接口）是程序员与Windows操作系统进行交互的核心工具。Windows API提供了大量的函数、接口和结构，使得开发者能够实现各种复杂的系统级功能。本篇将深入探讨Windows API开发，涵盖其...
UNIX多线程学习笔记
08-15
在Linux上，多线程编程主要依赖于POSIX线程库（pthread），它提供了与Windows SDK相应的API。理解并熟练使用这些API，是开发高效、可靠的多线程UNIX程序的关键。 在实际开发中，线程的创建、管理、同步和通信都需要...
谷粒商城实战笔记-175~177-商城业务-检索服务-检索查询接口开发
epitomizelu的专栏
08-13 761
搜索页面搭建完成之后，点击搜索按钮，发送参数给后台服务，后台服务根据参数从Elasticsearch中查询符合条件的数据，返回给前端。
经验笔记：URI、URL、URN与URC之间的区别
最新发布
qq_45831414的博客
08-14 585
URI是一种通用的标识符，可以指代任何类型的资源。URL是一种特定类型的URI，它不仅标识资源，还提供了访问该资源的方法。URN是一种用于唯一命名资源的特殊URI类型。URC是一个概念性的术语，用于描述如何构建或创建资源的过程。通过理解这些概念的区别，我们可以更加清晰地识别和使用互联网资源的标识方式。在日常工作中，我们最常遇到的是URL，因为它们是我们访问网页和其他在线资源的基础；而URN则在需要持久引用资源的情况下使用。
【Python】python中抽象类学习笔记
qq_42761751的博客
08-12 412
抽象类是一个不能被实例化的类，通常作为其他类的基类抽象方法是一个没有具体实现的方法一个抽象类可以有或者没有抽象方法, 但是一般来说定义抽象类的时候总会在类中定义抽象方法Python并没有直接支持抽象类，但是提供了一个模块（abc）来允许定义抽象类通过继承abc.ABC类定义一个抽象类pass上述代码中类虽然继承了ABC但是没有定义抽象方法，仍然可以被实例化。"""使用@abstractmethod来定义抽象方法"""passmain()代码报错：不能实例化一个带有抽象方法的抽象类。
C++_基本语法笔记_继承和多态
qq_45629864的博客
08-13 549
思想与Java差不多。
Windows API 学习笔记：从入门到精通
这些只是Windows API众多功能的一部分，实际的API还包括处理鼠标和键盘事件、绘制图形、管理内存、线程同步、网络通信等多个方面。学习和掌握Windows API有助于开发者创建高效、稳定且与Windows系统深度集成的应用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值