Windows编程基础 第十五章 线程局部存储 线程同步 原子锁 临界区 事件 互斥量 信号量 可等候定时器

最新推荐文章于 2021-03-10 15:45:50 发布
最新推荐文章于 2021-03-10 15:45:50 发布
阅读量964 收藏 2
点赞数
分类专栏： WIN32复习和学习笔记 文章标签： 编程 windows win32 vc++ c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangxuefeng09/article/details/39255779
版权 








//TLS线程局部存储的函数实现
//
#include "stdafx.h"
#include "windows.h"
#include "tchar.h"
#include "locale.h"

TCHAR * g_pszText=NULL;
DWORD g_nTlsIndex=0;

VOID  Print()
{
	//_tprintf(TEXT("g_pszText:%s\n"),g_pszText);
	//从指定的TLS索引中获取值
	TCHAR * pszText=(TCHAR *)TlsGetValue(g_nTlsIndex);
	_tprintf(TEXT("TLS:%s\n"),pszText);
}

DWORD WINAPI  PrintProc(LPVOID lpParameter)
{
	TCHAR * pszText=(TCHAR *)lpParameter;
	g_pszText=(TCHAR *)malloc(100);
	_tcscpy(g_pszText,pszText);
	TlsSetValue(g_nTlsIndex,g_pszText);
	while(1)
	{
		Print();
		Sleep(1000);
	}
	return 0;
}

VOID Create()
{
	HANDLE  hTread=NULL;
	DWORD nThreadId=0;

	TCHAR  szText1[]=TEXT("线程1-------------");
	hTread=CreateThread(NULL,0,PrintProc,szText1,0,&nThreadId);

	TCHAR  szText2[]=TEXT("-------------线程2");
	hTread=CreateThread(NULL,0,PrintProc,szText2,0,&nThreadId);

	WaitForSingleObject(hTread,INFINITE);
}


int _tmain(int argc, _TCHAR* argv[])
{
	setlocale(LC_ALL,"zhi");
	//创建TLS索引号
	g_nTlsIndex=TlsAlloc();
	Create();
	//释放TSL索引号
	TlsFree(g_nTlsIndex);
	return 0;
}



// 本程序演示原子锁的使用方式
//
#include "stdafx.h"
#include "windows.h"
#include "tchar.h"
#include "locale.h"

LONG g_lValue1=0;
LONG g_lValue2=0;

DWORD WINAPI  InterProc1(LPVOID lpParameter)
{
	for (int nIndex=0;nIndex<10000000;nIndex++)
	{
		g_lValue1++;
	}
	return 0;
}

DWORD WINAPI  InterProc2(LPVOID lpParameter)
{
	for (int nIndex=0;nIndex<10000000;nIndex++)
	{
		InterlockedIncrement(&g_lValue2);
	}
	return 0;
}

VOID Create()
{
	DWORD wThreadId=0;
	HANDLE hTread[4]={NULL};
	hTread[0]=CreateThread(NULL,0,InterProc1,NULL,0,&wThreadId);
	hTread[1]=CreateThread(NULL,0,InterProc1,NULL,0,&wThreadId);
	hTread[2]=CreateThread(NULL,0,InterProc2,NULL,0,&wThreadId);
	hTread[3]=CreateThread(NULL,0,InterProc2,NULL,0,&wThreadId);
	WaitForMultipleObjects(4,hTread,TRUE,INFINITE);
	//线程1和线程2都执行完毕之后，打印出数值，然后退出
	_tprintf(TEXT("Value1=%d,Value2=%d\n"),g_lValue1,g_lValue2);
}

int _tmain(int argc, _TCHAR* argv[])
{
	Create();
	return 0;
}


//本程序演示临界区的使用方式
//
#include "stdafx.h"
#include "windows.h"
#include "tchar.h"
#include "locale.h"

CRITICAL_SECTION  cs={0};
LONG lValue=0;

VOID Print()
{
	//进入临界区,临界区中可以有多条语句，会作为一个整体执行
	EnterCriticalSection(&cs);
	_tprintf(TEXT("LONG long  long .........\n"));
	lValue++;//这个语句的意思就是说明临界区可以实现原子锁的功能
	LeaveCriticalSection(&cs);
}

DWORD WINAPI PrintProc( LPVOID lpParameter )
{
	while(1)
	{
		Print();
		Sleep(1);
	}
	return 0;
}

VOID Create()
{
	DWORD nThreadID=0;
	HANDLE hThread[2]={0};
	hThread[0]=CreateThread(NULL,0,PrintProc,NULL,0,&nThreadID);
	hThread[1]=CreateThread(NULL,0,PrintProc,NULL,0,&nThreadID);
	getchar();
}

int _tmain(int argc, _TCHAR* argv[])
{
	InitializeCriticalSection(&cs);
	Create();
	DeleteCriticalSection(&cs);
	return 0;
}


//本程序演示事件的使用方式
#include "stdafx.h"
#include "windows.h"
#include "tchar.h"
#include "locale.h"


HANDLE g_hEvent1=NULL;
HANDLE g_hEvent2=NULL;

DWORD WINAPI ThreadSend( LPVOID lpParameter)
{
	while(1)
	{
		SetEvent(g_hEvent1);//触发事件1
		Sleep(500);
		SetEvent(g_hEvent2);//触发事件2
		Sleep(500);
	}
	return 0;
}

DWORD WINAPI ThreadRecv1( LPVOID lpParameter)
{
	while(1)
	{
		WaitForSingleObject(g_hEvent1,INFINITE);
		_tprintf(TEXT("Hello Event :%p\n"),g_hEvent1);
	}
	return 0;
}

DWORD WINAPI ThreadRecv2( LPVOID lpParameter)
{
	while(1)
	{
		WaitForSingleObject(g_hEvent2,INFINITE);
		_tprintf(TEXT("Hello Event :%p\n"),g_hEvent2);
		ResetEvent(g_hEvent2);//因为是手动重置事件，所以要手动的把事件设置成为无信号状态
	}
	return 0;
}


VOID Create()
{
	DWORD wThreadID=0;
	HANDLE  hTread[3]={NULL};
	hTread[0]=CreateThread(NULL,0,ThreadSend,NULL,0,&wThreadID);
	hTread[1]=CreateThread(NULL,0,ThreadRecv1,NULL,0,&wThreadID);
	hTread[2]=CreateThread(NULL,0,ThreadRecv2,NULL,0,&wThreadID);
}


int _tmain(int argc, _TCHAR* argv[])
{
	//创建自动重置事件
	g_hEvent1=CreateEvent(NULL,FALSE,FALSE,NULL);//创建一个自动重置事件，初始信号没有，匿名事件
	//创建一个手动事件
	g_hEvent2=CreateEvent(NULL,TRUE,FALSE,NULL);//创建一个手动重置事件，初始信号没有，匿名事件
	Create();
	getchar();
	CloseHandle(g_hEvent1);
	CloseHandle(g_hEvent2);
	return 0;
}

<pre name="code" class="cpp">//本程序演示互斥量的使用方式
#include "stdafx.h"
#include "windows.h"
#include "tchar.h"
#include "locale.h"


HANDLE g_Mutex=NULL;


DWORD WINAPI ThreadProc1( LPVOID lpParameter)
{
	while(1)
	{
		WaitForSingleObject(g_Mutex,INFINITE);
		_tprintf(TEXT("线程1-------------------------\n"));
		Sleep(500);
		ReleaseMutex(g_Mutex);		
	}
	return 0;
}

DWORD WINAPI ThreadProc2( LPVOID lpParameter)
{
	while(1)
	{
		WaitForSingleObject(g_Mutex,INFINITE);
		_tprintf(TEXT("-------------线程2------------\n"));
		Sleep(500);
		ReleaseMutex(g_Mutex);		
	}
	return 0;
}

DWORD WINAPI ThreadProc3( LPVOID lpParameter)
{
	while(1)
	{
		WaitForSingleObject(g_Mutex,INFINITE);
		_tprintf(TEXT("-------------------------线程3\n"));
		Sleep(500);
		ReleaseMutex(g_Mutex);	
	}
	return 0;
}


VOID Create()
{
	DWORD wThreadID=0;
	HANDLE  hTread[3]={NULL};
	hTread[0]=CreateThread(NULL,0,ThreadProc1,NULL,0,&wThreadID);
	hTread[1]=CreateThread(NULL,0,ThreadProc2,NULL,0,&wThreadID);
	hTread[2]=CreateThread(NULL,0,ThreadProc3,NULL,0,&wThreadID);
}


int _tmain(int argc, _TCHAR* argv[])
{
	setlocale(LC_ALL,"zhi");
	//创建互斥量
	g_Mutex=CreateMutex(NULL,FALSE,NULL);
	Create();
	getchar();
	CloseHandle(g_Mutex);
	return 0;
}


//本程序演示信号量的使用方式
#include "stdafx.h"
#include "windows.h"
#include "tchar.h"
#include "locale.h"
#include "stdio.h"
#include "conio.h"



HANDLE g_hSemphore=NULL;


DWORD WINAPI ThreadSend( LPVOID lpParameter)
{
	while(1)
	{
		TCHAR ch=_getch();
		switch(ch)
		{
		case  '1':
			_tprintf(TEXT("将会打印出一个语句！\n"));
			ReleaseSemaphore(g_hSemphore,1,NULL);
			break;
		case  '5':
			ReleaseSemaphore(g_hSemphore,5,NULL);
			_tprintf(TEXT("将会打印出五个语句！\n"));
			break;
		}
	}
	return 0;
}

DWORD WINAPI ThreadRecv( LPVOID lpParameter)
{
	while(1)
	{
		WaitForSingleObject(g_hSemphore,INFINITE);
		_tprintf(TEXT("Hello Semaphore!\n"));
		Sleep(1000);
	}
	return 0;
}


VOID Create()
{
	DWORD wThreadID=0;
	HANDLE  hTread[2]={NULL};
	hTread[0]=CreateThread(NULL,0,ThreadSend,NULL,0,&wThreadID);
	hTread[1]=CreateThread(NULL,0,ThreadRecv,NULL,0,&wThreadID);
	WaitForMultipleObjects(2,hTread,TRUE,INFINITE);
	
}


int _tmain(int argc, _TCHAR* argv[])
{
	setlocale(LC_ALL,"zhi");
	//创建互斥量
	g_hSemphore=CreateSemaphore(NULL,5,10,NULL);// 初始的时候5个信号量，也就是信号量创建出来的时候就会立刻发出5个信号。
	Create();
	getchar();
	CloseHandle(g_hSemphore);
	return 0;
}



 

 

//本程序演示可等候定时器的使用方式
#include "stdafx.h"
#include "windows.h"
#include "tchar.h"
#include "locale.h"
#include "stdio.h"
#include "conio.h"



HANDLE g_hTimer=NULL;

VOID CALLBACK TimerAPCProc(LPVOID lpArgToCompletionRoutine,DWORD dwTimerLowValue,DWORD dwTimerHighValue)
{
	_tprintf(TEXT("----------------APC  TIMER  PROC----------\n"));
}


DWORD WINAPI TimerThread( LPVOID lpParameter)
{
	while(1)
	{
		WaitForSingleObject(g_hTimer,INFINITE);
		_tprintf(TEXT("Hello Timer!\n"));
	}
	return 0;
}


VOID Create()
{
	//创建一个定时器
	g_hTimer=CreateWaitableTimer(NULL,FALSE,NULL);
	LARGE_INTEGER  DueTime={0};
	DueTime.QuadPart=-100000000;
	//设置定时器
	SetWaitableTimer(g_hTimer,&DueTime,1000,NULL,NULL,FALSE);
	//创建等候线程	
	DWORD wThreadID=0;
	HANDLE  hTread=NULL;
	hTread=CreateThread(NULL,0,TimerThread,NULL,0,&wThreadID);
	WaitForSingleObject(hTread,INFINITE);
	CloseHandle(hTread);
}

VOID APCTimer()
{
	HANDLE hTimer=CreateWaitableTimer(NULL,FALSE,NULL);
	LARGE_INTEGER  DueTime={0};
	DueTime.QuadPart=-10000;
	SetWaitableTimer(hTimer,&DueTime,1000,TimerAPCProc,NULL,FALSE);
	while (1)
	{
		SleepEx(-1,TRUE);
	}
	CloseHandle(hTimer);
}


int _tmain(int argc, _TCHAR* argv[])
{
	setlocale(LC_ALL,"zhi");
	//Create();
	APCTimer();
	return 0;
}

 

 

 

 

 


                

        

        

    




    

      

        

            

              
                
                  yangxuefeng09
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    2
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
每天进步一点点——Linux中的线程局部存储（一）

				
			

			

				

					Cynric 的博客
				

				

					05-21
					
					3万+
					
				

			

		

		

			
				
在Linux系统中使用C/C++进行多线程编程时有些数据无需使用锁即可做到快速高效，本文从线程局部存储出发讨论如何高效的实现无锁编程。

			
		

	



                

              
                



	

		

			

				
					
TLS线程局部存储

				
			

			

				

					dayenglish的专栏
				

				

					03-01
					
					1687
					
				

			

		

		

			
				
多线程程序当中，因为线程之间共享进程的数据，所以在访问全局数据的时候，可能需要加锁互斥访问。但是全局数据的互斥访问只有在多个线程之间协作进行处理的时候，才有必要。但是如果数据在各个线程之间都需要单独的副本，比如说VC CRT库当中的errno变量，我们希望这个变量仅仅由当前线程错误来设置，并且只影响当前线程，那么这种线程之间共享的副本数据该怎么实现呢？
微软提供的一种实现就是TLS（线程局部存储

			
		

	



                


  
              

                


	

		

			

				
					
深入理解原子操作-windows原子操作函数剖析

				
			

			

				

					ComputerInBook的专栏
				

				

					09-22
					
					1747
					
				

			

		

		

			
				
上一篇文章中， 我详细的整理了Intel处理器是如何在底层处理锁操的，在处理器指令集这一层次，
这也是软件和硬件开发人员所能见到的处理器的最后一层，下面我就从汇编这一层来看看windows是如何
封装原子操作函数的，了解清楚底层实现，以便在高并发中更好的利用原子操作。
  Windows有6个原子操作函数：
  InterlockedExchange:把目标操作数(参数1所指向的内存中的数)与一个值(参数2)交换，返回参数1的原始值。
  InterlockedCompareExch......

			
		

	





	

		

			

				
					
c++基础封装（线程、锁、定时器、原子操作等）

				
			

			

				

					09-29
				

			

		

		

			
				
定时器在C++中通常通过异步编程或者信号量实现，可以设置一个超时后触发的事件。例如，可以使用`std::this_thread::sleep_for`来实现简单的延迟：  ```cpp #include  #include  #include   void delayed_task() {  ...

			
		

	



		

			
		



	

		

			

				
					
【正点原子-miniSTM32F103-RT-Thread】示例-标准库版本.7z

				
			

			

				

					03-24
				

			

		

		

			
				
它提供了丰富的内核服务，如任务管理、内存管理、中断处理、信号量、互斥锁、事件标志组等，为开发者提供了灵活的多任务调度和同步机制。  在实验13和12中，分别介绍了信号量的动态和静态创建方法。信号量是一种用于...

			
		

	





	

		

			

				
					
【正点原子-战舰-精英STM32F103-RT-Thread】示例-标准库版本.7z

				
			

			

				

					03-24
				

			

		

		

			
				
5. 实验15：互斥信号量 - 互斥信号量是另一种同步工具，确保同一时间只有一个任务能访问特定资源，用于实现线程间的互斥访问。  6. 实验3：线程的创建和删除（动态方法） - 动态创建线程允许在程序运行时根据需要...

			
		

	





	

		

			

				
					
深入理解linux内核第三版中文版（4-7章,pdf格式）

				
			

			

				

					09-18
				

			

		

		

			
				
本章介绍了一系列内核同步原语，如自旋锁（spinlock）、读写锁（rwlock）、信号量（semaphore）、互斥量（mutex）等。这些机制确保了内核代码的安全性和正确性，防止了数据竞争和死锁。同时，还会讨论临界区的概念，...

			
		

	





	

		

			

				
					
SynchronizationFunctions(WindowsOS).pdf

				
			

			

				

					11-16
				

			

		

		

			
				
在Windows操作系统中，同步函数是一组用于协调多个线程访问共享资源的关键工具，确保数据的一致性和正确性。以下是一些主要的同步功能及其描述：  1. **临界区(Critical Section Functions)**：临界区是保护共享资源...

			
		

	





	

		

			

				
					
线程局部存储TLS

				
			

			

				

					complex_ok的专栏
				

				

					07-15
					
					4782
					
				

			

		

		

			
				
线程局部存储TLS堆栈中定义的局部变量，对多线程是安全的，因为不同的线程有自己的堆栈。而通常定义的全局变量，所有线程都可以作读写访问，这样它就不是线程安全的，为安全就有必要加锁互斥访问。而何为线程局部存储（TLS），简单的说，就是一个变量（通常是指针，指向具体的类型），每个线程都有一个副本，而在程序中可以按照相同的方式来访问，（比如使用相同的变量名，又或者都调用TlsGetValue），既然是

			
		

	





	

		

			

				
					
笔记VC

				
			

			

				

					xd_ladan的专栏
				

				

					01-14
					
					1699
					
				

			

		

		

			
				
滚动条信息结构 LPSCROLLBARINFO  编译报错找不到时，在stdafx.h最前面加上#define WINVER 0x500








===============================================C语言==============================================
strcpy() //拷贝参数2

			
		

	





	

		

			

				
					
线程同步：原子操作、锁、二元信号量、信号量、互斥量、临界区、读写锁、条件变量等

				
			

			

				

					rongwenbin的专栏
				

				

					01-17
					
					2794
					
				

			

		

		

			
				
注：摘自《程序员的自我修养》相关章节。
 
原子操作
共享数据（全局变量或堆变量）的自增（++）操作在多线程环境下会出现错误是因为这个操作（一条c语句）被编译为汇编代码后不止一条指令，因此在执行的时候可能执行了一半就被调度系统打断，去执行别的代码。
我们把单指令的操作称为原子的（Atomic）,因为无论如何，单条指令的执行是不会被打断的。为了避免出错，很多体系结构都提供了一些常用操作的原子

			
		

	





	

		

			

				
					
进程和线程的总结（两者区别、通讯方式、死锁）

				
			

			

				

					qq_44685867的博客
				

				

					03-10
					
					861
					
				

			

		

		

			
				
一、线程和进程的区别：
1、首先是定义
进程：是执行中一段程序，即一旦程序被载入到内存中并准备执行，它就是一个进程。进程是表示资源分配的的基本概念，又是调度运行的基本单位，是系统中的并发执行的单位。
线程：单个进程中执行中每个任务就是一个线程。线程是进程中执行运算的最小单位。
2、一个线程只能属于一个进程，但是一个进程可以拥有多个线程。多线程处理就是允许一个进程中在同一时刻执行多个任务。
3、线程是一种轻量级的进程，与进程相比，线程给操作系统带来侧创建、维护、和管理的负担要轻，意味着线程的代价或开销比较小。

			
		

	





	

		

			

				
					
Windows编程基础 第十章    组合框  列表框  滚动条   自绘制控件

				
			

			

				

					学峰的学习笔记
				

				

					09-06
					
					2387
					
				

			

		

		

			
				
//本程序用来演示ComboBox
#include "windows14.h"
#include "stdafx.h"
#include "resource.h"
#include "stdio.h"
#include "windows.h"

HINSTANCE g_hInst=NULL;
VOID OnAdd(HWND hWnd);
VOID OnDel(HWND hWnd);
VOID O

			
		

	





	

		

			

				
					
Windows编程基础  第二章   Unicode编码   NMAKE命令解释器

				
			

			

				

					学峰的学习笔记
				

				

					09-01
					
					1571
					
				

			

		

		

			
				
一、NMAKE和Makefile
   1.1、 NMAKE - 命令解释器，根据Makefile文件中定义的脚本，完成项目的编译等操作。
     1.2、Makefile - 定义编译/链接等脚本语言。
  Makefile.mak  文件  注意用tab键而不是用空格
  Nmake/ ? 就可以看到nmake常用的一些参数。
例如：window.exe:

			
		

	





	

		

			

				
					
Windows编程基础  第七章    windows绘图    windows绘图设备

				
			

			

				

					学峰的学习笔记
				

				

					09-04
					
					1481
					
				

			

		

		

			
				
// windows09.cpp : 定义应用程序的入口点。
//
#include "windows09.h"
#include "stdafx.h"
#include "resource.h"
#include "stdio.h"
#include "windows.h"

HINSTANCE g_hInst=NULL;
INT   g_hDrawType=0;
INT  g_PenwWidt

			
		

	





	

		

			

				
					
Windows编程基础 第十二章   磁盘    目录    文件   查找文件

				
			

			

				

					学峰的学习笔记
				

				

					09-09
					
					1342
					
				

			

		

		

			
				
// windows20.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "locale.h"
VOID  ShowSpace(TCHAR * pszDrive)
{
 /*主要是两个函数的使用和一个结构体的使用
BOOL WINAPI GetDiskFreeSpace(
__in   LPCTSTR lpRootPathName,
__

			
		

	



              



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

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值