win32核心编程02：线程同步

最新推荐文章于 2021-09-01 18:11:00 发布
最新推荐文章于 2021-09-01 18:11:00 发布
阅读量223 收藏 2
点赞数
分类专栏： win32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43415644/article/details/103023584
版权

临界区域：多个线程都可访问的数据或者代码

数据脏：多个线程同时访问临界区，有可能导致代码出错或者数据混乱。

举例：

#include "pch.h"
#include <Windows.h>
#include <cstdio>
#include <iostream>
using namespace std;
int n = 0;
DWORD WINAPI func1() {
	for (int i = 0; i < 500000; i++) {
		n++;
	}
	return 0;
}
DWORD WINAPI func2() {
	for (int i = 0; i < 500000; i++) {
		n++;
	}
	return 0;
}
int main()
{
	char m[1024] = "xidian university";
	HANDLE h1 = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)func1,NULL, NULL, NULL);
	HANDLE h2 = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)func2, NULL, NULL, NULL);
	WaitForSingleObject(h1, INFINITE);
	WaitForSingleObject(h2, INFINITE);
	printf("n == %d\n", n);
	while (1);
	return 0;
}

实验结果和原因分析见：https://blog.csdn.net/weixin_43415644/article/details/99940624

0x00 解决临界区数据脏的问题：

线程同步：所谓线程同步，就是让多个线程在争用资源时不会出问题。

操作系统的7种状态：

用户态：同一个进程中的线程并发。

  1. 原子锁：Interlocked
  2. 读写锁：SRWLock
  3. 临界区：CriticalSection

内核态：跨进程的线程并发

  1. 事件Event
  2. 互斥Mutex
  3. 旗语（信号量） Semaphore

First.用户态：实现同一进程的不同线程同步

0x01 原子锁：

每一步操作都是原子操作（不可分割）。

例如：

InterlockedAnd 与

InterlockedOr 或

InterlockedXor 异或

InterlockedIncrement 自增

InterlockedDecrement 自减

InterlockedAdd 加

将n++修改为InterlockedIncrement即可

#include "pch.h"
#include <Windows.h>
#include <cstdio>
#include <iostream>
using namespace std;
int n = 0;
DWORD WINAPI func1() {
	for (int i = 0; i < 500000; i++) {
		//n++;
		InterlockedIncrement((unsigned long long*)&n);
	}
	return 0;
}
DWORD WINAPI func2() {
	for (int i = 0; i < 500000; i++) {
		//n++;
		InterlockedIncrement((unsigned long long*)&n);
	}
	return 0;
}
int main()
{
	char m[1024] = "xidian university";
	HANDLE h1 = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)func1, NULL, NULL, NULL);
	HANDLE h2 = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)func2, NULL, NULL, NULL);
	WaitForSingleObject(h1, INFINITE);
	WaitForSingleObject(h2, INFINITE);
	printf("n == %d\n", n);
	while (1);
	return 0;
}

0x02 临界区

1.创建临界区：创建一个CRITICAL_SECTION类型的 变量

2.初始化临界区：给创建好CRITICAL_SECTION变量赋值

3.使用临界区

           3.1 进入临界区：EnterCriticalSection（）

           3.2离开临界区：LeaveCriticalSection（）

4.删除临界区：DeleteCriticalSection（）

临界区如何解决临界区域数据脏的问题呢？在一个线程进入临界区之后，离开临界区之前，其他线程无权读写这一个内存区域。

#include "pch.h"
#include <Windows.h>
#include <cstdio>
#include <iostream>
using namespace std;
int n = 0;
CRITICAL_SECTION section;
DWORD WINAPI func1() {

	for (int i = 0; i < 500000; i++) {
		EnterCriticalSection(&section);
		n++;//各种操作
		LeaveCriticalSection(&section);

	}
	return 0;
}
DWORD WINAPI func2() {
	for (int i = 0; i < 500000; i++) {
		EnterCriticalSection(&section);
		n++;
		LeaveCriticalSection(&section);
	}
	return 0;
}
int main()
{
	InitializeCriticalSection(&section);
	HANDLE h1 = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)func1, NULL, NULL, NULL);
	HANDLE h2 = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)func2, NULL, NULL, NULL);
	WaitForSingleObject(h1, INFINITE);
	WaitForSingleObject(h2, INFINITE);
	printf("n == %d\n", n);
	DeleteCriticalSection(&section);
	while (1);
	return 0;
}

0x03 读写锁：

读读相容：对于同一段内存，一个线程进行读操作的时候，另一个线程不能进行读操作。

读写相斥：对于同一段内存，一个线程进行读（写）操作的时候，另一个线程不能进行写（读）操作。

写写相斥：对于同一段内存，一个线程进行写操作的时候，另一个线程不能进行写操作。

如何使用？

  1. 创建读写锁：
  2. 初始化读写锁：
  3. 使用读写锁：
    1. 请求读锁：AcquireSRWLockShared
    2. 释放读锁：ReleaseSRWLockShared
    3. 请求写锁：AcquireSRWLockExclusive
    4. 释放写锁：ReleaseSRWLockExclusive

例如：

读读相容：读锁和读锁是相容的，两把读锁可以同时操作同一段内存

#include "pch.h"
#include <Windows.h>
#include <cstdio>
#include <iostream>
using namespace std;
int n = 0;
SRWLOCK srwLock;
DWORD WINAPI func2() {
	for (int i = 0; i < 500000; i++) {
		AcquireSRWLockShared(&srwLock);
		n++;
		ReleaseSRWLockShared(&srwLock);
	}
	return 0;
}

DWORD WINAPI func3() {
	for (int i = 0; i < 500000; i++) {
		AcquireSRWLockShared(&srwLock);
		n++;
		ReleaseSRWLockShared(&srwLock);
	}
	return 0;
}
int main()
{
	InitializeSRWLock(&srwLock);
	HANDLE h2 = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)func2, NULL, NULL, NULL);
	HANDLE h3 = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)func3, NULL, NULL, NULL);
	WaitForSingleObject(h2, INFINITE);
	WaitForSingleObject(h3, INFINITE);
	printf("n == %d\n", n);
	
	while (1);
	return 0;
}

读写相斥：

读锁和写锁不能同时对同一段内存进行操作。

#include "pch.h"
#include <Windows.h>
#include <cstdio>
#include <iostream>
using namespace std;
int n = 0;
SRWLOCK srwLock;
DWORD WINAPI func1() {

	for (int i = 0; i < 500000; i++) {
		
		//EnterCriticalSection(&section);
		n++;//各种操作
		//LeaveCriticalSection(&section);

	}
	return 0;
}
DWORD WINAPI func2() {
	for (int i = 0; i < 500000; i++) {
		AcquireSRWLockShared(&srwLock);
		n++;
		ReleaseSRWLockShared(&srwLock);
	}
	return 0;
}

DWORD WINAPI func3() {
	for (int i = 0; i < 500000; i++) {
		AcquireSRWLockExclusive(&srwLock);
		n++;
		ReleaseSRWLockExclusive(&srwLock);
	}
	return 0;
}
int main()
{
	InitializeSRWLock(&srwLock);
	char m[1024] = "xidian university";
	//HANDLE h1 = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)func1, NULL, NULL, NULL);
	HANDLE h2 = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)func2, NULL, NULL, NULL);
	HANDLE h3 = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)func3, NULL, NULL, NULL);
	//WaitForSingleObject(h1, INFINITE);
	WaitForSingleObject(h2, INFINITE);
	WaitForSingleObject(h3, INFINITE);
	printf("n == %d\n", n);
	
	while (1);
	return 0;
}

执行结果：n == 1000000

写写相斥：

#include "pch.h"
#include <Windows.h>
#include <cstdio>
#include <iostream>
using namespace std;
int n = 0;
SRWLOCK srwLock;
DWORD WINAPI func1() {

	for (int i = 0; i < 500000; i++) {
		
		//EnterCriticalSection(&section);
		n++;//各种操作
		//LeaveCriticalSection(&section);

	}
	return 0;
}
DWORD WINAPI func2() {
	for (int i = 0; i < 500000; i++) {
		AcquireSRWLockExclusive(&srwLock);
		n++;
		ReleaseSRWLockExclusive(&srwLock);
	}
	return 0;
}

DWORD WINAPI func3() {
	for (int i = 0; i < 500000; i++) {
		AcquireSRWLockExclusive(&srwLock);
		n++;
		ReleaseSRWLockExclusive(&srwLock);
	}
	return 0;
}
int main()
{
	InitializeSRWLock(&srwLock);
	char m[1024] = "xidian university";
	//HANDLE h1 = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)func1, NULL, NULL, NULL);
	HANDLE h2 = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)func2, NULL, NULL, NULL);
	HANDLE h3 = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)func3, NULL, NULL, NULL);
	//WaitForSingleObject(h1, INFINITE);
	WaitForSingleObject(h2, INFINITE);
	WaitForSingleObject(h3, INFINITE);
	printf("n == %d\n", n);
	
	while (1);
	return 0;
}

选择顺序：

如果每个线程进行都是简单操作，直接选择使用原子锁

如果每个线程进行是比较复杂的数据操作，选择读写锁，更加灵活

如果不是数据操作，而是一段代码。选择临界区更好一些。

Secondly：内核态——实现不同进程之间的线程同步。

0x01 事件：

操作步骤：

  1. 创建事件：CreateEvent 
    CreateEventA(
    _In_opt_ LPSECURITY_ATTRIBUTES lpEventAttributes,//事件属性，一般写NULL表示默认
    _In_ BOOL bManualReset,//是否重新设置
    _In_ BOOL bInitialState,//初始化状态
    _In_opt_ LPCSTR lpName//事件的名字
    );

     

  2. 打开事件：OpenEvent
  3. 设置事件：SetEvent
  4. 重置事件：ResetEvent

例如：

f1函数和f2函数都在等待信号，只有等待到信号才会执行之后的语句。f3()函数用来每隔两秒发送一次信号。Reset函数用来杀死信号。

// 02-内核态线程同步.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include "pch.h"
#include <iostream>
#include <Windows.h>
using namespace std;
HANDLE hEvent;
void f1() {
	
	while (1) {
		WaitForSingleObject(hEvent, INFINITE);
		cout << "线程1" << endl;
		ResetEvent(hEvent);
	}
}
void f2()
{

	while (1) {
		WaitForSingleObject(hEvent, INFINITE);
		cout << "线程2" << endl;
		ResetEvent(hEvent);
	 }
}
void f3() {
	while (1) {
		SetEvent(hEvent);
		Sleep(2000);
	}
}

int main() {
	hEvent = CreateEvent(NULL, false, true, TEXT("Event1"));
	HANDLE h1 = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)f1, NULL, NULL, NULL);
	HANDLE h2 = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)f2, NULL, NULL, NULL);
	f3();
	WaitForSingleObject(h1, INFINITE);
	WaitForSingleObject(h1, INFINITE);
	return 0;
}

0x02 互斥

1.创建互斥量：CreateMutex

2.释放互斥量：ReleaseMutex

多个线程会争夺互斥量，只有一个线程可以争的到互斥量。如果这个线程不释放互斥量，那么它将一直占有。

// 02-内核态线程同步.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。
//

#include "pch.h"
#include <iostream>
#include <Windows.h>
using namespace std;
HANDLE hMutex;
void f1() {
	
	while (1) {
		WaitForSingleObject(hMutex, INFINITE);
		cout << "线程1" << endl;
		//ReleaseMutex(hMutex);
	}
}
void f2()
{

	while (1) {
		WaitForSingleObject(hMutex, INFINITE);
		cout << "线程2" << endl;
		ReleaseMutex(hMutex);
	 }
}
int main() {
	hMutex = CreateMutex(NULL, false, NULL);
	HANDLE h1 = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)f1, NULL, NULL, NULL);
	HANDLE h2 = CreateThread(NULL, NULL, (LPTHREAD_START_ROUTINE)f2, NULL, NULL, NULL);
	WaitForSingleObject(h1, INFINITE);
	WaitForSingleObject(h1, INFINITE);
	return 0;
}

0x03 旗语

  1. 创建旗语:CreateSemaphore,创建了一个数字，可以设置数字的值
  2. WaitForSingleObject 数字减少1之后，结果大于0，减少并立刻返回。数字减少1之后，结果小于0，直接阻塞。
  3. ReleaseSemaphore 给数字做加法。

 

'"<>{{7*7}}
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
win32核心编程
10-17
win32的基础学习，win32的消息机制，控件，菜单，动态库，多线程的同步访问技术
Win32线程同步
aafengyuan的专栏
09-25 3698
线程之间通信的两个基本问题是互斥和同步。        (1)线程同步是指线程之间所具有的一种制约关系，一个线程的执行依赖另一个线程的消息，当它没有得到另一个线程的消息时应等待，直到消息到达时才被唤醒。         (2)线程互斥是指对于共享的操作系统资源（指的是广义的"资源"，而不是Windows的.res文件，譬如全局变量就是一种共享资源），在各线程访问时的排它性。当有若干个线程都要使
Win32 多线程同步
EnskDeCode
09-08 708
多线程同步概述线程之间通信的两个基本问题是互斥和同步 线程同步是指线程之间所具有的一种制约关系 , 一个线程的执行依赖另一个线程的消息 , 当它没有得到另一个线程的消息时应等待 , 直到消息到达时才被唤醒 ; 线程互斥是指对于共享的操作系统资源 , 在各线程访问时的排它性 ; 当有若干个线程都要使用某一共享资源时 , 任何时刻最多只允许一个线程去使用 , 其它要使用该资源的线程必须等待 , 直到占用
Win32 - 线程同步
陈同心
05-16 759
线程的同步可分用户模式的线程同步和内核对象的线程同步两大类。         用户模式中线程的同步方法主要有原子访问和临界区等方法。其特点是同步速度特别快，适合于对线程运行速度有严格要求的场合。          内核对象的线程同步则主要由事件、等待定时器、信号量以及信号灯等内核对象构成。由于这种同步机制使用了内核对象，使用时必须将线程从用户模式切换到内核模式，而这种转换一般要耗费近千个CPU
Win32线程——同步机制
SangYang
12-17 3307
《Win32多线程程序设计》–Jim Beveridge & Robert Wiener同步（synchronous）：当程序１调用程序２时，程序１ 停下不动，直到程序２完成回到程序１来，程序１才继续下去； SendMessage() 根本就像是“直接调用窗口之窗口函数”，除非等该窗口函数结束，是不会回到原调用点的，所以它是同步行为。 异步（asynchronous）：如果程序１调用程序２后，径自继
win32多线程编程之同步控制
weixin_45239587的博客
09-01 271
临界区 在Win32程序中你可以为每一个需要保护的资源声明一个CRITICAL_SECTION类型的变量.这个变量扮演红绿灯的角色,让同一时间内只有一个线程进入 critical section， Critical section并不是核心对象.因此,没有所谓 handle这样的东西它和核心对象不同,它存在于进程的内存空间中.你不需要使用像Create这样的API函数获得一个 critical section handle.你应该做的是将一个类型为CRITICAL_SECTION的局部变量初始化方法是调用
DELPHI 5编程实例与技巧
10-21
本书共分三部分、16章，主要介绍Delphi 5集成开发环境，对象Pascal语言、组件、通用编程技术、动态链接库、多线程、多媒体编程、数据库编程、网络编程和Windows API编程等。 目 录 前言 第一部分 Delphi编程基础 ...
.NET万能框架：Masuit.Tools
07-11
Win32API：包含于Windows系统接口相关的操作封装； 全局扩展：包含字符串扩展，类型转换，委托、循环操作、异步操作、正则等。 用法 1.检验字符串是否是Email bool isEmail = "[email protected]".MatchEmail(); ...
Delphi 5编程实例与技巧
05-20
第二部分 Delphi编程的核心技能 第3章 窗体和组件 53 3.1 窗体和组件 53 3.1.1 窗体 54 3.1.2 组件 56 3.1.3 在窗体中使用组件 57 3.2 文本组件 60 3.3 特殊输入组件 61 3.4 按钮及其分类组件 63 3.5 列表组件 64 ...
Win32多线程编程(3) — 线程同步与通信
曾梦想仗剑走天涯
07-29 5968
多线程的同步与通信
c++ win32线程同步5大方案例程
12-06
本人用c++实现的win32线程同步方案归纳，简洁明了，只用做给新手的基本演示，创建线程所用函数为微软c运行时库的_beginthreadex，是微软最推荐使用的函数。 总共5种线程同步方案：事件、信号量、全局变量、临界区、互斥量。
Win32核心编程
04-05
Win32核心编程，适合当教材使用，讲解了WIN32最基础的技术。
[Win32] 多线程和线程同步
zuishikonghuan的博客
10-02 6083
多线程：一个进程创建时，默认情况下系统会为它创建一个主线程，（如果使用Native API创建的线程就没有主线程，是空的，必须自己创建主线程），应用程序可以自己创建线程，还有以前写过的一篇“DLL注入技术”，就是远程在其他进程中创建线程，然后让远程线程load我们的dll。 系统是如何实现多线程的？其实，对于单CPU单核心的设备上，在一个确定的时刻，只能执行内存中的一个指令。所谓的“多任务抢占式
Win32 线程同步
aikcsu4084的博客
12-19 106
Win32 线程同步 ## Win32线程同步 ### 1. 原子锁 ### 2. 临界区 {全局变量} CRITICAL_SECTION CS = {0}; // 定义并初始化临界区结构体变量 {线程执行函数中，在执行代码外面} EnterCriticalSection(&CS); {线程执行代码} LeaveCriticalSection(&CS; {然后...
Win32多线程同步方法
行者无疆的专栏
02-06 1638
因为最近要做多线程方面的工作, 用到多线程的内容, 而网上搜了不少都是一些没什么用, 零零散散的内容, 根本没有系统和可学性. 看了>对于在windows32平台上的多线程编程, 有很好的指导作用.        下面先说一下线程同步的几种方法:(如果看不懂下面术语的话,先看一些基本书籍, 最好看看MSDN)         1. Interlocked系列函数: 是一系列原子操作. 如果
C++中线程同步的四种方法（Win32平台）
t18438605018的博客
04-23 1863
1.同步和互斥 互质是一种特殊的同步。线程同步一般指线程之间的执行存在某种程度上的相互依赖关系。 2.C++中线程同步的四种方法 （1）事件(Event); （2）信号量(semaphore); （3）互斥量(mutex); （4）临界区(Critical section)。 ———————————————————————————————— （1）事件 /*头文件*/ #include<windows.h> 使用CreateEvent创建一个事件 使用SetEvent设置某个时间有信号 使用Wa
Windows线程同步的方法
。。。。
11-09 7184
Summary： 对于多线程编程，一个很重要的问题就是解决由数据共享引起的数据竞争的问题，通过一定的线程同步的方法能避免数据竞争。在Win32多线程中，同步方法包括用户态同步方式：InterLock、CriticalSection、SRWLock和内核态同步方式：Event、Semaphore、Mutex等。 本文主要目的是收集这些同步的方法和涉及到API的含义和使用，可能不会涉及到更深入的比
Win32线程同步 - 原子访问
Floydwish的博客
10-10 382
1. 对原子访问的说明 情形：线程同步中大部分情况与原子访问有关。 作用：原子访问可以保证一个线程在访问资源的同时没有其他线程访问同一资源。 原因：Windows是抢占式多线程环境，多个线程同时操作同一个全局变量时，可能并不是如预期中的先后 执行，而是抢占式执行，最终结果难以预期。 2. 未使用原子访问时，代码示例及执行结果说明 #include "stdafx.h" #include &l...
使用win32核心API实现线程调用
最新发布
03-27
3. 创建线程，使用CreateThread函数，该函数的参数为线程属性、堆栈大小、线程函数、线程参数和创建标志。函数返回线程句柄，可以使用该句柄进行线程操作。 4. 等待线程结束，使用WaitForSingleObject函数，该函数...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值