Windows线程

线程基础

• Windows线程是可以执行的代码的实例。

  系统是以线程为单位调度程序，一个程序中可以有多个线程，实现多任务的处理。主线程只能有一个。

• Windows线程的特点

  1. 线程都具有1个ID
  2. 每个线程都具有自己的内存栈，其余的共享。
  3. 同一进程中的线程使用同一个地址空间。(除了栈空间)

• 线程的调度

  操作系统将CPU的执行时间划分为时间片，依次根据时间片执行不同的线程。

  线程轮询: 线程A -> 线程B ->线程A …

创建线程

• 创建线程

  HANDLE CreateThread(LPSECURITY_ATTRIBUTES lpThreadAttributes , // 安全属性，已废弃， NULLSIZE_T dwStackSize, // 线程栈的大小  按1M对齐，最少1MLPTHREAD_START_ROUTINE lpStartAddress, // 线程处理函数的函数地址，自己定义由系统调用LPVOID lpParameter, // 传递给线程处理函数的参数DWORD dwCreationFlags, // 线程的创建方式(立即执行&挂起方式)// 0 -> 立即启动// CREATE_SUSPENDED -> 挂起LPDWORD lpThreadId // 创建成功，返回线程的ID
  ); // 创建成功，返回线程句柄  ( 线程句柄和线程ID都可以代表线程 )
  

• 定义线程处理函数

  DWORD WINAPI ThreadProc(LPVOID lpParameter // 创建线程时，传递给线程的参数
  );
  

Demo

#include 
#include 
DWORD CALLBACK TestProc(LPVOID pParam){char * pszText = (char *) pParam;printf("%s",pszText);
}
int main(){DWORD nID = 0;char * pszText = "******";HANDLE hThread = CreateThread(NULL,0,TestProc,pszText,0,&nID);getchar();return 0;
}

子线程正常执行->要保证主线程不结束

销毁线程

• 挂起

  DWORD SuspendThread(HANDLE hThread // 线程句柄
  );
  

• 唤醒

  DWORD ResumeThread(HANDLE hThread  // 线程句柄
  );
  

• 结束指定线程

  BOOL TerminateThread(HANDLE hThread, // 线程句柄DWORD dwExitCode // 退出码，一般没用
  );
  

• 结束函数所在的线程

  VOID ExitThread(DWORD dwExitCode // 退出码，没有实际意义
  );
  // 自杀 -> 只能干掉调用的线程
  

线程相关操作

• 获取当前线程ID

  GetCurrentThreadId();
  

• 获取当前线程的句柄

  GetCurrentThread();
  

• 等候单个句柄有信号

  VOID WaitForSingleObject(HANDLE handle , // 句柄BUFF的地址DWORD dwMilliseconds // 最长等候时间 ms// INFINITE 一直等待
  );
  // 有信号时会立即返回
  // 没有信号会阻塞
  

  线程句柄是可等候句柄： 有信号和无信号状态

• 同时等候多个句柄有信号

  DWORD WaitForMultipleObject(DWORD nCount, // 句柄数量CONST HANDLE *lpHandles, // 句柄BUFF的地址BOOL bWaitAll, // 等候方式// TRUE : 所有句柄都有信号才会返回// FALSE: 只要有一个有信号就返回DWORD dwMilliseconds // 等候时间  INFINITE
  );
  

  可等候句柄

• 线程信号

  • 当线程处于执行状态时，线程无信号
  • 当线程结束那刻，线程有信号

线程同步

原子锁

• 当多个线程对同一个数据进行原子操作，会产生结果丢失，比如算术运算

• 使用原子锁函数

  InterlockedIncrement   // ++ 操作符
  InterlockedDecrement   // --
  InterlockedCompareExchange   // 三目运算符 
  InterlockedExchange    // = 赋值
  

  原子锁的实现，直接对数据所在的内存操作，并且任何一个瞬间只能有一个线程访问。

• 只能对运算符加锁，效率高，但是麻烦

互斥锁

• 相关问题

  多线程下代码或者资源的共享使用

• 互斥的使用

  1. 创建互斥

     HANDLE CreateMutex(LPSECURITY_ATTRIBUTES lpMutexAttributes, // 安全数据(NULL)BOOL bInitialOwner, // 初始的拥有者 TRUE/FALSE// TRUE: 哪个线程创建哪个线程拥有// FALSE: 都不拥有LPCTSTR lpName // 命名
     ); // 创建成功返回互斥句柄
     // 互斥句柄，也是可等候句柄
     

     • 在任何时间点上只有一个线程拥有互斥， 独占性和排他性

     • 当任何线程都不拥有互斥，互斥有信号，任何一个线程拥有互斥，互斥就没有信号

  2. 等候互斥

     WaitFor… 函数

     互斥的等候遵循谁先等候谁先获得

     也就是加锁

  3. 释放互斥

     BOOL ReleaseMutex(HANDLE hMutex // 互斥锁句柄
     );
     

  4. 关闭互斥句柄

     CloseHandle
     

demo

#include 
#include HANDLE hmutex; // 接收互斥句柄 DWORD CALLBACK TestProc(LPVOID pParam){char * pszText = (char *) pParam;int i ;while(1){WaitForSingleObject(hmutex,INFINITE);for(i = 0;iprintf("%c",pszText[i]);Sleep(125);}printf("\n");ReleaseMutex(hmutex); } 
}
int main(){hmutex = CreateMutex(NULL,FALSE,NULL); DWORD nID1 = 0;DWORD nID2 = 0;char * pszText1 = "******";char * pszText2 = "------";HANDLE hThread1 = CreateThread(NULL,0,TestProc,pszText1,0,&nID1);HANDLE hThread2 = CreateThread(NULL,0,TestProc,pszText2,0,&nID2);getchar();CloseHandle(hmutex);return 0;
}

事件

• 相关问题

  线程之间的通知问题

• 事件的使用

  1. 创建事件

     HANDLE CreateEvent(LPSEURITY_ATTRIBUTES lpEventAttributes, // 安全属性BOOL bManualReset, // 事件重置(复位)方式 有信号 -> 无信号// TRUE  手动// FALSE 自动 --> 读取信号一次就会自动复位// 触发 无信号 ->有信号BOOL bInitialState ,// 事件初始状态，TRUE 有信号LPCTSTR lpName // 事件命名，可以为空
     );// 创建成功返回事件句柄
     

     可等候句柄

     事件的有信号无信号可控制

  2. 等候事件

     WaitForSingleObject  / WaitForMultipleObjects
     // 自动复位方式，会自动复位
     

  3. 触发事件( 将事件设置为有信号状态)

     BOOL SetEvent(HANDLE hEvent //handle to event
     );
     

  4. 复位事件( 将事件设置为无信号状态 )

     BOOL ResetEvent(HANDLE hEvent
     );
     

  5. 关闭事件

     CloseHandle
     

要小心事件的死锁问题

demo

#include 
#include 
HANDLE g_hEvent = 0; // 接收事件句柄DWORD CALLBACK PrintProc(LPVOID pParam){while(1){WaitForSingleObject(g_hEvent,INFINITE); // 等待信号 ResetEvent(g_hEvent); printf("......\n");}
}DWORD CALLBACK CtrlProc(LPVOID pParam){while(1){Sleep(1000);SetEvent(g_hEvent);}
} 
int main(){g_hEvent = CreateEvent(NULL,TRUE,FALSE,NULL);DWORD nID = 0;HANDLE hThread[2] = {0};hThread[0] = CreateThread(NULL,0,PrintProc,NULL,0,&nID); hThread[1] = CreateThread(NULL,0,CtrlProc,NULL,0,&nID);WaitForMultipleObjects(2,hThread,TRUE,INFINITE);CloseHandle(g_hEvent);return 0; 
}

信号量

• 相关的问题

  作用类似于事件，解决通知的相关问题。

  提供一个计数器，可以设置次数

• 信号量的使用

  1. 创建信号量

     HANDLE CreateSemaphore(LPSECTRITY_ATTRIBUTES lpSemaphoreAttributes, // 安全属性LONG lInitialCount, // 初始化信号量数量// 信号量计数值为0时，没有信号// 信号量计数值不为0，有信号LONG lMaximumCount, // 信号量最大个数LPCTSTR lpName // 命名
     );// 创建成功返回信号量句柄
     

     可等候句柄

  2. 等候信号量

     WaitFor ...
     // 每等候通过一次，信号量的信号减1，直到为0阻塞
     

  3. 给信号量指定计数值

     BOOL ReleaseSemaphore(HANDLE hSemaphore, // 信号量句柄LONG lReleaseCount ,// 释放数量LPLONG lpPreviousCount // 返回的信息，返回释放前原来信号量的数量，可以为NULL
     );
     

  4. 关闭句柄

     CloseHandle
     

demo

#include 
#include 
HANDLE g_hSema = 0;// 保存信号量句柄DWORD CALLBACK TestProc(LPVOID pParam){while(1){WaitForSingleObject(g_hSema,INFINITE);printf("*****\n");}
}int main(){g_hSema = CreateSemaphore(NULL,3,10,NULL);DWORD nID = 0;HANDLE hThread = CreateThread(NULL,0,TestProc,NULL,0,&nID);getchar();ReleaseSemaphore(g_hSema,5,NULL);WaitForSingleObject(hThread,INFINITE);CloseHandle(g_hSema);	return 0;
}