c++多线程

《编程思想之多线程与多进程(1)——以操作系统的角度述说线程与进程》一文详细讲述了线程、进程的关系及在操作系统中的表现，《编程思想之多线程与多进程(2)——线程优先级与线程安全》一文讲了线程安全(各种同步锁)和优先级，这是多线程学习必须了解的基础。本文将接着讲一下C++中多线程程序的开发.这里主要讲Windows平台线程的用法，创建线程要调用windows API的CreateThread方法。

 

创建线程

在Windows平台，Windows API提供了对多线程的支持。前面进程和线程的概念中我们提到，一个程序至少有一个线程，这个线程称为主线程(main thread)，如果我们不显示地创建线程，那我们产的程序就是只有主线程的间线程程序。
下面，我们看看Windows中线程相关的操作和方法：

CreateThread与CloseHandle

CreateThread用于创建一个线程，其函数原型如下：

C++

1 2 3 4 5 6 7 8

HANDLE WINAPI CreateThread (      LPSECURITY_ATTRIBUTES   lpThreadAttributes , //线程安全相关的属性，常置为NULL      SIZE_T                   dwStackSize ,          //新线程的初始化栈在大小，可设置为0      LPTHREAD_START_ROUTINE   lpStartAddress ,      //被线程执行的回调函数，也称为线程函数      LPVOID                   lpParameter ,          //传入线程函数的参数，不需传递参数时为NULL      DWORD                   dwCreationFlags ,      //控制线程创建的标志      LPDWORD                 lpThreadId            //传出参数，用于获得线程ID，如果为NULL则不返回线程ID ) ;

**说明：**lpThreadAttributes：指向SECURITY_ATTRIBUTES结构的指针，决定返回的句柄是否可被子进程继承，如果为NULL则表示返回的句柄不能被子进程继承。

dwStackSize ：线程栈的初始化大小，字节单位。系统分配这个值对

lpStartAddress：指向一个函数指针，该函数将被线程调用执行。因此该函数也被称为线程函数(ThreadProc)，是线程执行的起始地址，线程函数是一个回调函数，由操作系统在线程中调用。线程函数的原型如下：

C++

1	DWORD WINAPI ThreadProc ( LPVOID lpParameter ) ; //lpParameter是传入的参数，是一个空指针

lpParameter：传入线程函数(ThreadProc)的参数，不需传递参数时为NULL

dwCreationFlags：控制线程创建的标志，有三个类型，0：线程创建后立即执行线程；CREATE_SUSPENDED：线程创建后进入就绪状态，直到线程被唤醒时才调用；STACK_SIZE_PARAM_IS_A_RESERVATION：dwStackSize 参数指定线程初始化栈的大小，如果STACK_SIZE_PARAM_IS_A_RESERVATION标志未指定，dwStackSize将会设为系统预留的值。

返回值：如果线程创建成功，则返回这个新线程的句柄，否则返回NULL。如果线程创建失败，可通过GetLastError函数获得错误信息。

C++

1	BOOL WINAPI CloseHandle ( HANDLE hObject ) ; //关闭一个被打开的对象句柄

可用这个函数关闭创建的线程句柄，如果函数执行成功则返回true(非0),如果失败则返回false(0)，如果执行失败可调用GetLastError.函数获得错误信息。

【Demo1】：创建一个最简单的线程

C++

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

#include "stdafx.h" #include <windows.h> #include <iostream>   using namespace std ;   //线程函数 DWORD WINAPI ThreadProc ( LPVOID lpParameter ) {      for ( int i = 0 ; i < 5 ; ++ i )      {          cout << "子线程:i = " << i << endl ;          Sleep ( 100 ) ;      }      return 0L ; }   int main ( ) {      //创建一个线程      HANDLE thread = CreateThread ( NULL , 0 , ThreadProc , NULL , 0 , NULL ) ;      //关闭线程      CloseHandle ( thread ) ;        //主线程的执行路径      for ( int i = 0 ; i < 5 ; ++ i )      {          cout << "主线程:i = " << i << endl ;          Sleep ( 100 ) ;      }        return 0 ; }

结果如下：

C++

1 2 3 4 5 6 7 8 9 10

主线程 : i = 0 子线程 : i = 0 主线程 : i = 1 子线程 : i = 1 子线程 : i = 2 主线程 : i = 2 子线程 : i = 3 主线程 : i = 3 子线程 : i = 4 主线程 : i = 4

【Demo2】：在线程函数中传入参数

C++

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62

#include "stdafx.h" #include <windows.h> #include <iostream>   using namespace std ;   #define NAME_LINE   40   //定义线程函数传入参数的结构体 typedef struct __THREAD_DATA {      int nMaxNum ;      char strThreadName [ NAME_LINE ] ;        __THREAD_DATA ( ) : nMaxNum ( 0 )      {          memset ( strThreadName , 0 , NAME_LINE * sizeof ( char ) ) ;      } } THREAD_DATA ;       //线程函数 DWORD WINAPI ThreadProc ( LPVOID lpParameter ) {      THREAD_DATA * pThreadData = ( THREAD_DATA * ) lpParameter ;        for ( int i = 0 ; i < pThreadData -> nMaxNum ; ++ i )      {          cout << pThreadData -> strThreadName << " --- " << i << endl ;          Sleep ( 100 ) ;      }      return 0L ; }   int main ( ) {      //初始化线程数据      THREAD_DATA threadData1 , threadData2 ;      threadData1 . nMaxNum = 5 ;      strcpy ( threadData1 . strThreadName , "线程1" ) ;      threadData2 . nMaxNum = 10 ;      strcpy ( threadData2 . strThreadName , "线程2" ) ;   //创建第一个子线程      HANDLE h Thread1 = CreateThread ( NULL , 0 , ThreadProc , &threadData1 , 0 , NULL ) ;      //创建第二个子线程      HANDLE h Thread2 = CreateThread ( NULL , 0 , ThreadProc , &threadData2 , 0 , NULL ) ;      //关闭线程      CloseHandle ( hThread1 ) ;      CloseHandle ( hThread2 ) ;        //主线程的执行路径      for ( int i = 0 ; i < 5 ; ++ i )      {          cout << "主线程 === " << i << endl ;          Sleep ( 100 ) ;      }        system ( "pause" ) ;      return 0 ; }

结果：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

主线程 === 线程 1 — 0 0 线程 2 — 0 线程 1 — 1 主线程 === 1 线程 2 — 1 主线程 === 2 线程 1 — 2 线程 2 — 2 主线程 === 3 线程 2 — 3 线程 1 — 3 主线程 === 4 线程 2 — 4 线程 1 — 4 线程 2 — 5 请按任意键继续… 线程 2 — 6 线程 2 — 7 线程 2 — 8 线程 2 — 9

CreateMutex、WaitForSingleObject、ReleaseMutex

从【Demo2】中可以看出，虽然创建的子线程都正常执行起来了，但输出的结果并不是我们预期的效果。我们预期的效果是每输出一条语句后自动换行，但结果却并非都是这样。这是因为在线程执行时没有做同步处理，比如第一行的输出，主线程输出“主线程 ===”后时间片已用完，这时轮到子线程1输出，在子线程输出“线程1 —”后时间片也用完了，这时又轮到主线程执行输出“0”，之后又轮到子线程1输出“0”。于是就出现了“主线程 === 线程1 — 0 0”的结果。

主线程：cout << “主线程 === ” << i << endl;
子线程：cout << pThreadData->strThreadName << ” — ” << i << endl;

为避免出现这种情况，我们对线程做一些简单的同步处理，这里我们用互斥量(Mutex)，关于互斥量(Mutex)的概念，请看《编程思想之多线程与多进程(2)——线程优先级与线程安全》一文；更多C++线程同步的处理，请看下一节。

在使用互斥量进行线程同步时会用到以下几个函数：

C++

1 2 3 4 5

HANDLE WINAPI CreateMutex (      LPSECURITY_ATTRIBUTES lpMutexAttributes ,          //线程安全相关的属性，常置为NULL      BOOL                    bInitialOwner ,              //创建Mutex时的当前线程是否拥有Mutex的所有权      LPCTSTR               lpName                      //Mutex的名称 ) ;

**说明：**lpMutexAttributes也是表示安全的结构，与CreateThread中的lpThreadAttributes功能相同，表示决定返回的句柄是否可被子进程继承，如果为NULL则表示返回的句柄不能被子进程继承。bInitialOwner表示创建Mutex时的当前线程是否拥有Mutex的所有权，若为TRUE则指定为当前的创建线程为Mutex对象的所有者，其它线程访问需要先ReleaseMutex。lpName为Mutex的名称。

C++

1 2 3 4

DWORD WINAPI WaitForSingleObject (      HANDLE hHandle ,                              //要获取的锁的句柄      DWORD   dwMilliseconds                            //超时间隔 ) ;

**说明：**WaitForSingleObject的作用是等待一个指定的对象(如Mutex对象)，直到该对象处于非占用的状态(如Mutex对象被释放)或超出设定的时间间隔。除此之外，还有一个与它类似的函数WaitForMultipleObjects，它的作用是等待一个或所有指定的对象，直到所有的对象处于非占用的状态，或超出设定的时间间隔。

hHandle：要等待的指定对象的句柄。dwMilliseconds：超时的间隔，以毫秒为单位；如果dwMilliseconds为非0，则等待直到dwMilliseconds时间间隔用完或对象变为非占用的状态，如果dwMilliseconds 为INFINITE则表示无限等待，直到等待的对象处于非占用的状态。

C++

1	BOOL WINAPI ReleaseMutex ( HANDLE h Mutex ) ;

说明：释放所拥有的互斥量锁对象，hMutex为释放的互斥量的句柄。

【Demo3】：线程同步

C++

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72

#include "stdafx.h" #include <windows.h> #include <iostream>   #define NAME_LINE   40   //定义线程函数传入参数的结构体 typedef struct __THREAD_DATA {      int nMaxNum ;      char strThreadName [ NAME_LINE ] ;        __THREAD_DATA ( ) : nMaxNum ( 0 )      {          memset ( strThreadName , 0 , NAME_LINE * sizeof ( char ) ) ;      } } THREAD_DATA ;   HANDLE g_hMutex = NULL ;      //互斥量   //线程函数 DWORD WINAPI ThreadProc ( LPVOID lpParameter ) {      THREAD_DATA * pThreadData = ( THREAD_DATA * ) lpParameter ;        for ( int i = 0 ; i < pThreadData -> nMaxNum ; ++ i )      {          //请求获得一个互斥量锁          WaitForSingleObject ( g_hMutex , INFINITE ) ;          cout << pThreadData -> strThreadName << " --- " << i << endl ;          Sleep ( 100 ) ;          //释放互斥量锁          ReleaseMutex ( g_hMutex ) ;      }      return 0L ; }   int main ( ) {      //创建一个互斥量      g_hMutex = CreateMutex ( NULL , FALSE , NULL ) ;        //初始化线程数据      THREAD_DATA threadData1 , threadData2 ;      threadData1 . nMaxNum = 5 ;      strcpy ( threadData1 . strThreadName , "线程1" ) ;      threadData2 . nMaxNum = 10 ;      strcpy ( threadData2 . strThreadName , "线程2" ) ;          //创建第一个子线程      HANDLE hThread1 = CreateThread ( NULL , 0 , ThreadProc , &threadData1 , 0 , NULL ) ;      //创建第二个子线程      HANDLE hThread2 = CreateThread ( NULL , 0 , ThreadProc , &threadData2 , 0 , NULL ) ;      //关闭线程      CloseHandle ( hThread1 ) ;      CloseHandle ( hThread2 ) ;        //主线程的执行路径      for ( int i = 0 ; i < 5 ; ++ i )      {          //请求获得一个互斥量锁          WaitForSingleObject ( g_hMutex , INFINITE ) ;          cout << "主线程 === " << i << endl ;          Sleep ( 100 ) ;          //释放互斥量锁          ReleaseMutex ( g_hMutex ) ;      }        system ( "pause" ) ;      return 0 ; }

结果：

C++

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

主线程 === 0 线程 1 — 0 线程 2 — 0 主线程 === 1 线程 1 — 1 线程 2 — 1 主线程 === 2 线程 1 — 2 线程 2 — 2 主线程 === 3 线程 1 — 3 线程 2 — 3 主线程 === 4 线程 1 — 4 请按任意键继续… 线程 2 — 4 线程 2 — 5 线程 2 — 6 线程 2 — 7 线程 2 — 8 线程 2 — 9

为进一步理解线程同步的重要性和互斥量的使用方法，我们再来看一个例子。

买火车票是大家春节回家最为关注的事情，我们就简单模拟一下火车票的售票系统(为使程序简单，我们就抽出最简单的模型进行模拟)：有500张从北京到赣州的火车票，在8个窗口同时出售，保证系统的稳定性和数据的原子性。

【Demo4】：模拟火车售票系统

C++

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47

#include "stdafx.h" #include <windows.h> #include <iostream> #include <strstream> #include <string>   using namespace std ;   #define NAME_LINE   40   //定义线程函数传入参数的结构体 typedef struct __TICKET {      int nCount ;      char strTicketName [ NAME_LINE ] ;        __TICKET ( ) : nCount ( 0 )      {          memset ( strTicketName , 0 , NAME_LINE * sizeof ( char ) ) ;      } } TICKET ;   typedef struct __THD_DATA {      TICKET * pTicket ;      char strThreadName [ NAME_LINE ] ;        __THD_DATA ( ) : pTicket ( NULL )      {          memset ( strThreadName , 0 , NAME_LINE * sizeof ( char ) ) ;      } } THD_DATA ;     //基本类型数据转换成字符串 template < class T > string convertToString ( const T val ) {      string s ;      std :: strstream ss ;      ss << val ;      ss >> s ;      return s ; }   //售票程序 DWORD WINAPI SaleTicket ( LPVOID lpParameter ) ;

SaleTickets.cpp ：

C++

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

#include "stdafx.h" #include <windows.h> #include <iostream> #include "SaleTickets.h"   using namespace std ;   extern HANDLE g_hMutex ;   //售票程序 DWORD WINAPI SaleTicket ( LPVOID lpParameter ) {        THD_DATA * pThreadData = ( THD_DATA * ) lpParameter ;      TICKET * pSaleData = pThreadData -> pTicket ;      while ( pSaleData -> nCount > 0 )      {          //请求获得一个互斥量锁          WaitForSingleObject ( g_hMutex , INFINITE ) ;          if ( pSaleData -> nCount > 0 )          {              cout << pThreadData -> strThreadName << "出售第" << pSaleData -> nCount -- << "的票," ;              if ( pSaleData -> nCount >= 0 ) {                  cout << "出票成功!剩余" << pSaleData -> nCount << "张票." << endl ;              } else {                  cout << "出票失败！该票已售完。" << endl ;              }          }          Sleep ( 10 ) ;          //释放互斥量锁          ReleaseMutex ( g_hMutex ) ;      }        return 0L ; }

测试程序：

C++

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38

//售票系统 void Test2 ( ) {      //创建一个互斥量      g_hMutex = CreateMutex ( NULL , FALSE , NULL ) ;        //初始化火车票      TICKET ticket ;      ticket . nCount = 100 ;      strcpy ( ticket . strTicketName , "北京-->赣州" ) ;        const int THREAD_NUMM = 8 ;      THD_DATA threadSale [ THREAD_NUMM ] ;      HANDLE hThread [ THREAD_NUMM ] ;      for ( int i = 0 ; i < THREAD_NUMM ; ++ i )      {          threadSale [ i ] . pTicket = &ticket ;          string strThreadName = convertToString ( i ) ;            strThreadName = "窗口" + strThreadName ;            strcpy ( threadSale [ i ] . strThreadName , strThreadName . c_str ( ) ) ;            //创建线程          hThread [ i ] = CreateThread ( NULL , NULL , SaleTicket , &threadSale [ i ] , 0 , NULL ) ;            //请求获得一个互斥量锁          WaitForSingleObject ( g_hMutex , INFINITE ) ;          cout << threadSale [ i ] . strThreadName << "开始出售 " << threadSale [ i ] . pTicket -> strTicketName << " 的票..." << endl ;          //释放互斥量锁          ReleaseMutex ( g_hMutex ) ;            //关闭线程          CloseHandle ( hThread [ i ] ) ;      }        system ( "pause" ) ; }

结果：

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25

窗口 0开始出售 北京– & gt ;赣州 的票… 窗口 0出售第 100的票 ,出票成功 !剩余 99张票 . 窗口 1开始出售 北京– & gt ;赣州 的票… 窗口 1出售第 99的票 ,出票成功 !剩余 98张票 . 窗口 0出售第 98的票 ,出票成功 !剩余 97张票 . 窗口 2开始出售 北京– & gt ;赣州 的票… 窗口 2出售第 97的票 ,出票成功 !剩余 96张票 . 窗口 1出售第 96的票 ,出票成功 !剩余 95张票 . 窗口 0出售第 95的票 ,出票成功 !剩余 94张票 . 窗口 3开始出售 北京– & gt ;赣州 的票… 窗口 3出售第 94的票 ,出票成功 !剩余 93张票 . 窗口 2出售第 93的票 ,出票成功 !剩余 92张票 . 窗口 1出售第 92的票 ,出票成功 !剩余 91张票 . 窗口 0出售第 91的票 ,出票成功 !剩余 90张票 . 窗口 4开始出售 北京– & gt ;赣州 的票… 窗口 4出售第 90的票 ,出票成功 !剩余 89张票 . 窗口 3出售第 89的票 ,出票成功 !剩余 88张票 . 窗口 2出售第 88的票 ,出票成功 !剩余 87张票 . 窗口 1出售第 87的票 ,出票成功 !剩余 86张票 . 窗口 0出售第 86的票 ,出票成功 !剩余 85张票 . 窗口 5开始出售 北京– & gt ;赣州 的票… 窗口 5出售第 85的票 ,出票成功 !剩余 84张票 . 窗口 4出售第 84的票 ,出票成功 !剩余 83张票 . 窗口 3出售第 83的票 ,出票成功 !剩余 82张票 . 窗口 2出售第 82的票 ,出票成功 !剩余 81张票 .