C++windows内核编程笔记day14 其他线程同步技术

线程同步技术：
原子锁
临界区（段）
互斥
事件
信号量(线程示例时已经使用过)
可等候定时器

使用范围：原子锁<临界区<互斥
效率：    原子锁>临界区（用户态）>互斥（内核态）
一般用临界区。

//等候多个信号
DWORD WaitForMultipleObjects(
  DWORD nCount,             // number of handles in array
  CONST HANDLE *lpHandles,  // object-handle array
  BOOL bWaitAll,            // wait option
  DWORD dwMilliseconds      // time-out interval
);
bWaitAll:
TRUE-所有句柄都有信号才结束等候
FALSE-有一个就结束等候(返回值为有信号的句柄的下标)
dwMilliseconds:
INFINITE-等待
等待的毫秒数-时间到了或信号到了就结束
使用：
HANDLE ht[2]={0};
ht[0]=hthread1;
ht[1]=hthread2;
WaitForMultipleObjects(2,ht,TRUE,INFINITE);
在临界资源前加 _declspec(thread)  可以解决部分操作被覆盖的问题。
day76 pm over
原子锁函数的使用:
InterlockedIncrement --自加
InterlockedDecrement --自减
LONG InterlockedCompareExchange(
  LPLONG volatile Destination,  // destination address
  LONG Exchange,                // exchange value
  LONG Comperand                // value to compare
);
InterlockedExchange --等号赋值
原子锁实现:
锁住变量所在内存,同一时间只能有一个线程操作.
示例:
long g_val=0;
InterlockedIncrement(&g_val);

原子锁使用示例:

#include "stdafx.h"
#include<windows.h>
#include <STDIO.H>
long g_val=0;
DWORD CALLBACK TestProc1(LPVOID param)
{
//	sprintf(g_txt,"%s",(char*)param);
	//char*txt=(char*)param;
	for(int i=0;i<10000;i++)
	{
		//g_val++;
		InterlockedIncrement(&g_val);
		//printf("test1 thread,g_val=%d!\n",g_val);
	}

	return 0;
}
DWORD CALLBACK TestProc2(LPVOID param)
{
	//sprintf(g_txt,"%s",(char*)param);
	//char*txt=(char*)param;
	for(int i=0;i<10000;i++)
	{
		//g_val++;
		InterlockedIncrement(&g_val);
		InterlockedExchange
		//printf("test2 thread,g_val=%d!\n",g_val);
	}
	return 0;
}
int main(int argc, char* argv[])
{
	HANDLE ht[2]={0};
	DWORD tid=0;
	ht[0]=CreateThread(NULL,0,TestProc1,NULL,0,&tid);
	ht[1]=CreateThread(NULL,0,TestProc2,NULL,0,&tid);
	WaitForMultipleObjects(2,ht,TRUE,INFINITE);
	printf("最终结果：%d\n",g_val);
	CloseHandle(ht[0]);
	CloseHandle(ht[1]);
	return 0;
}

临界区:
锁定一段代码,防止多个线程同时使用该段代码.
１、初始化临界区(主线程调用):
VOID InitializeCriticalSection(
  LPCRITICAL_SECTION lpCriticalSection  // critical section
);
２、进入临界区(子线程调用)
VOID EnterCriticalSection(
  LPCRITICAL_SECTION lpCriticalSection  // critical section
);
３、离开临界区(子线程调用)
VOID LeaveCriticalSection(
  LPCRITICAL_SECTION lpCriticalSection   // critical section
);
４、删除临界区(主线程调用)
VOID DeleteCriticalSection(
  LPCRITICAL_SECTION lpCriticalSection   // critical section
);
临界区使用示例:
CRITICAL_SECTION cs={0};
void Thread()
{
DWORD tid=0;
char *txt="**************************";
HANDLE hthread1=CreateThread(NULL,0,TestProc1,txt,
0,&tid);
char *txt2="—————————————";
HANDLE hthread2=CreateThread(NULL,0,TestProc2,txt2,
0,&tid);
//SuspendThread(hthread1);
//ResumeThread(hthread2);
HANDLE ht[2]={0};
ht[0]=hthread1;
ht[1]=hthread2;
WaitForMultipleObjects(2,ht,TRUE,INFINITE);
CloseHandle(hthread1);
CloseHandle(hthread2);
}

int main(int argc, char* argv[])
{
InitializeCriticalSection(&cs);
Thread();
DeleteCriticalSection(&cs);
return 0;
}
//在线程1处理函数TestProc1中锁定代码
EnterCriticalSection(&cs);
printf("*****************************\n");
LeaveCriticalSection(&cs);
//在线程2处理函数TestProc2中锁定代码
EnterCriticalSection(&cs);
printf("____________________\n");
LeaveCriticalSection(&cs);

互斥Mutex（可以通过互命名的方式跨进程使用）：
1、创建互斥，返回句柄
HANDLE CreateMutex(  LPSECURITY_ATTRIBUTES lpMutexAttributes,  // SD
  BOOL bInitialOwner,// initial owner，是否本线程拥有
  LPCTSTR lpName // object name
);
bInitialOwner:
TRUE-调用CreateMutex的线程拥有互斥
FALSE-创建的时候没有线程拥有互斥
2、等候互斥
WaitFor
3、释放互斥
BOOL ReleaseMutex(HANDLE hMutex);
4、关闭互斥句柄
CloseHandle(HANDLE hMutex);

互斥示例：
HANDLE g_hMutex=0;
//在线程1处理函数中使用互斥体等待
WaitForSingleObject(g_hMutex,INFINITE);
printf("*****************************\n");
ReleaseMutex(g_hMutex);
//在线程2处理函数中使用互斥体等待
WaitForSingleObject(g_hMutex,INFINITE);
printf("………………………………………………………………………………\n");
ReleaseMutex(g_hMutex);
void Thread()
{
DWORD tid=0;
char *txt="**************************";
HANDLE hthread1=CreateThread(NULL,0,TestProc1,txt,
0,&tid);
char *txt2="—————————————";
HANDLE hthread2=CreateThread(NULL,0,TestProc2,txt2,
0,&tid);
HANDLE ht[2]={0};
ht[0]=hthread1;
ht[1]=hthread2;
WaitForMultipleObjects(2,ht,TRUE,INFINITE);
CloseHandle(hthread1);
CloseHandle(hthread2);
}

int main(int argc, char* argv[])
{
g_hMutex=CreateMutex(0,FALSE,"m1");
Thread();
CloseHandle(g_hMutex);
return 0;
}
事件：
1、创建事件
HANDLE CreateEvent(  LPSECURITY_ATTRIBUTES lpEventAttributes, // SD
  BOOL bManualReset,// reset type
  BOOL bInitialState,// initial state
  LPCTSTR lpName // object name
);
bManualReset：
true-调用WaitFor(……)后，手动调用ResetEvent(复位)
false-调用WaitFor(……)时，WaitFor(……)中会自动复位
2、等候信号
WaitForSingleObject/WaitForMultipleObjects
3、将事件设置成有信号状态
BOOL SetEvent(  HANDLE hEvent);
将事件设置成无信号状态
BOOL ResetEvent(  HANDLE hEvent);
4关闭事件

事件使用示例主要代码：

HANDLE g_hevent=0;
DWORD CALLBACK PrintProc(LPVOID param)
{
while(1)
{
WaitForSingleObject(g_hevent,INFINITE);//有信号才执行
ResetEvent(g_hevent);//把信号设置为无信号，等待其他线程发信号
printf("**************************\n");

}
return 0;
}
DWORD CALLBACK CtrlProc(LPVOID param)
{
int i=0;
while(1)
{
SetEvent(g_hevent);//发一个信号
Sleep(1000);
i++;
if(i==1000) break;
}
return 0;
}
void Thread()
{
DWORD tid=0;
char *txt="**************************";
HANDLE hthread1=CreateThread(NULL,0,PrintProc,txt,
0,&tid);
char *txt2="—————————————";
HANDLE hthread2=CreateThread(NULL,0,CtrlProc,txt2,
0,&tid);
HANDLE ht[2]={0};
ht[0]=hthread1;
ht[1]=hthread2;
WaitForMultipleObjects(2,ht,TRUE,INFINITE);
CloseHandle(hthread1);
CloseHandle(hthread2);
}

int main(int argc, char* argv[])
{
g_hevent=CreateEvent(0,TRUE,FALSE,"e1");
Thread();
CloseHandle(g_hevent);
return 0;

}

可等候定时器
解决程序之间的通知问题,第一次启动时间以100纳秒(0.0001毫秒)为单位.
1、创建可等候定时器
HANDLE CreateWaitableTimer(
  LPSECURITY_ATTRIBUTES lpTimerAttributes, // SD
  BOOL bManualReset,// 是否手动复位
  LPCTSTR lpTimerName // 名称,可以为NULL
);
2、设置定时器
BOOL SetWaitableTimer(
  HANDLE hTimer, // handle to timer
  const LARGE_INTEGER *pDueTime, //第一次启动时间
  LONG lPeriod,//间隔时间
  PTIMERAPCROUTINE pfnCompletionRoutine,// 回调函数
  LPVOID lpArgToCompletionRoutine,//回调函数参数
  BOOL fResume//待机处理标识
);
pDueTime:
正数-绝对时间(年月日时分秒)
负数-绝对值为相对时间(0.0001毫秒为单位)
lPeriod:
以毫秒为单位,为0时,只执行一次.
fResume:
TRUE-如果机器正要待机，能解除待机
FALSE-放弃待机
3、等候信号
WaitFor(...)
注意:可等候定时器只适用于NT5.0及以上版本,得定义系统版本
#define _WIN32_WINNT 0X500

示例:

// winTimer.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#define _WIN32_WINNT 0X500
#include <WINDOWS.H>
#include<STDIO.H>
HANDLE g_hTimer=0;
DWORD WINAPI TestProc(  LPVOID lpParameter)
{
	while(1)
	{
		WaitForSingleObject(g_hTimer,INFINITE);
		printf("************************\n");
	}
}
int main(int argc, char* argv[])
{
	g_hTimer=CreateWaitableTimer(NULL,FALSE,"t1");
	//INT64 nDueTime=-10000000;//相对时间
	//LARGE_INTEGER li=(LARGE_INTEGER*)&nDueTime;
	SYSTEMTIME st={0};
	st.wYear=2014;
	st.wMonth=7;
	st.wDay=13;
	st.wHour=15;
	st.wMinute=13;
	st.wSecond=30;
	FILETIME ft={0};
	SystemTimeToFileTime(&st,&ft);//系统时间转换为本地时间
	FILETIME ft2={0};
	LocalFileTimeToFileTime(&ft,&ft2);//将本地时间转换为全球标准时间
	LARGE_INTEGER li={0};
	li.HighPart=ft2.dwHighDateTime;
	li.LowPart=ft2.dwLowDateTime;

	DWORD tid=0;
	SetWaitableTimer(g_hTimer,&li,3000,NULL,NULL,FALSE);
	HANDLE ht=CreateThread(NULL,0,TestProc,NULL,0,&tid);
	WaitForSingleObject(ht,INFINITE);
	CloseHandle(ht);
	CloseHandle(g_hTimer);
	return 0;
}

win32 编程部分结束。

时间： 2024-11-03 12:26:38

C++windows内核编程笔记day14 其他线程同步技术的相关文章

C++windows内核编程笔记day13 进程、线程与信号量

Windows进程 进程是一个容器,包含程序执行需要的代码.数据.资源等信息, windows进程的特点:每个进程都有自己的ID号每个进程都有自己的地址空间,进程之间无法访问对方的地址空间.每个进程都有自己的安全属性每个进程至少包含一个线程. 获取和释放环境信息 GetEnvironmentStrings FreeEnvironmentStrings 获取或设置 本程序的环境变量 GetEnvironmentVariable SetEnvironmentVariable 示例:char* env

C++windows内核编程笔记day01_day02

windows编程介绍.windows 库和头文件介绍 exe文件:.exe,可执行文件 静态库文件:*.lib,调用时,源代码嵌入到调用位置 动态库文件:*.dll,调用时,函数地址被传入 --写编译软件,要懂编译原理. windows 库和头文件 kernel32.dll-提供了核心的API,例如进程.线程.内存管理等 user32.dll-提供了窗口消息等API gdi32.dll-绘图相关的API windows.h-所有windows头文件的集合 windef.h-windows数据类

C++windows内核编程笔记day09_day10,对话框和窗口基本控件等的使用

//设置字体颜色 SetTextColor(hdc,RGB(255,0,0)); //窗口背景 //wce.hbrBackground=(HBRUSH)(COLOR_WINDOW+1); //wce.hbrBackground=CreateSolidBrush(RGB(0,0,255)); //设置字体背景 SetBkColor(hdc,RGB(0,0,200)); //设置字体背景模式 SetBkMode(hdc,TRANSPARENT);//字体背景透明 //创建字体,成功返回字体,失败返回

C++windows内核编程笔记day11 win32静态库和动态库的使用

windows库程序: 静态库: 源代码被链接到调用的程序或动态库,被调用时,代码最少有1份,文件后缀.LIB 动态库: 函数被程序或其他动态库调用,被调用时,代码只有1份,文件后缀.DLL 静态库(C语言): 创建时,选择文本类型文件,输入Clib.c,设置输出路径 ../lib/Clib.lib int Clib_add(int a,int b) {return a+b; } 同一上工作区,建立控制台程序(.c文件)调用静态库: #include<STDIO.H> #pragma comm

C++windows内核编程笔记day07_day08,可视化建菜单、加速键使用、绘图等

可视化操作创建的菜单,加载到窗口. 方法1:注册时指定菜单 wce.lpszMenuName=MAKEINTRESOURCE(IDR_MENUMAIN);//数字形式的资源ID转换为字符串形式的资源 方法2: //创建窗口时加载菜单资源 HMENU menumain= LoadMenu(g_hinstance,MAKEINTRESOURCE(IDR_MENUMAIN)); menumain 传入 CreateWindowEx();//倒数第三个参数 窗口指定小图标: 1.注册时指定 wce.hI

c++windows内核编程笔记day12 硬盘逻辑分区管理、文件管理、内存管理

windows系统磁盘文件存储: 分区格式:NTFS / FAT32 GetSystemDirectory();//获取系统路径 GetWindowsDirectory();//获取windows路径 GetCurrentDirectory();//获取当前工作目录 SetCurrentDirectory();//修改当前工作目录 CreateFile/ReadFile/WriteFile/GetFileSize/SetFilePointer //返回文件大小的低32位 DWORD GetFil

C++windows内核编程笔记day03_day04_day05

windows消息机制.消息格式和消息处理1 unicode支持,windows下用: 1.先在#include<windows.h>上面,定义 UNICODE #define UNICODE 2.定义字符串 TCHAR * ptxt=TEXT("学习hello c++"); 3.根据需要,打印不同格式字符串 #ifdef UNICODE     wprintf(L"%s\n",ptxt); #else     printf("%s\n&quo

C++windows内核编程笔记day06 代码创建菜单

创建菜单: HMENU CreateMenu(VOID); 添加菜单项: BOOL AppendMenu(  HMENU hMenu,         // handle to menu   UINT uFlags,         // menu-item options   UINT_PTR uIDNewItem, // identifier, menu, or submenu   LPCTSTR lpNewItem    // menu-item content   );  uFlags:

Visual C++线程同步技术剖析

  摘要: 多线程同步技术是计算机软件开发的重要技术,本文对多线程的各种同步技术的原理和实现进行了初步探讨. 关键词: VC++6.0: 线程同步:临界区:事件:互斥:信号量: 阅读目录: 使线程同步 临界区 管理事件内核对象 信号量内核对象 互斥内核对象 小结 正文 使线程同步 在程序中使用多线程时,一般很少有多个线程能在其生命期内进行完全独立的操作.更多的情况是一些线程进行某些处理操作,而其他的线程必须对其处理结果进行了解.正常情况下对这种处理结果的了解应当在其处理任务完成后进行. 如果不采