多线程与多进程
Posted Ricky2016
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了多线程与多进程相关的知识，希望对你有一定的参考价值。
创建线程
在Windows平台，Windows API提供了对多线程的支持。前面进程和线程的概念中我们提到，一个程序至少有一个线程，这个线程称为主线程(main thread)，如果我们不显示地创建线程，那我们产的程序就是只有主线程的间线程程序。
下面，我们看看Windows中线程相关的操作和方法：
CreateThread与CloseHandle
CreateThread用于创建一个线程，其函数原型如下：
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)，是线程执行的起始地址，线程函数是一个回调函数，由操作系统在线程中调用。线程函数的原型如下：
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函数获得错误信息。
BOOL WINAPI CloseHandle(HANDLE hObject); //关闭一个被打开的对象句柄
可用这个函数关闭创建的线程句柄，如果函数执行成功则返回true(非0),如果失败则返回false(0)，如果执行失败可调用GetLastError.函数获得错误信息。
【Demo1】：创建一个最简单的线程
1 #include "stdafx.h" 2 #include <windows.h> 3 #include <iostream> 4 5 using namespace std; 6 7 //线程函数 8 DWORD WINAPI ThreadProc(LPVOID lpParameter) 9 { 10 for (int i = 0; i < 5; ++ i) 11 { 12 cout << "子线程:i = " << i << endl; 13 Sleep(100); 14 } 15 return 0L; 16 } 17 18 int main() 19 { 20 //创建一个线程 21 HANDLE thread = CreateThread(NULL, 0, ThreadProc, NULL, 0, NULL); 22 //关闭线程 23 CloseHandle(thread); 24 25 //主线程的执行路径 26 for (int i = 0; i < 5; ++ i) 27 { 28 cout << "主线程:i = " << i << endl; 29 Sleep(100); 30 } 31 32 return 0; 33 }
结果如下：
主线程:i = 0
子线程:i = 0
主线程:i = 1
子线程:i = 1
子线程:i = 2
主线程:i = 2
子线程:i = 3
主线程:i = 3
子线程:i = 4
主线程:i = 4
【Demo2】：在线程函数中传入参数
1 #include "stdafx.h" 2 #include <windows.h> 3 #include <iostream> 4 5 using namespace std; 6 7 #define NAME_LINE 40 8 9 //定义线程函数传入参数的结构体 10 typedef struct __THREAD_DATA 11 { 12 int nMaxNum; 13 char strThreadName[NAME_LINE]; 14 15 __THREAD_DATA() : nMaxNum(0) 16 { 17 memset(strThreadName, 0, NAME_LINE * sizeof(char)); 18 } 19 }THREAD_DATA; 20 21 22 23 //线程函数 24 DWORD WINAPI ThreadProc(LPVOID lpParameter) 25 { 26 THREAD_DATA* pThreadData = (THREAD_DATA*)lpParameter; 27 28 for (int i = 0; i < pThreadData->nMaxNum; ++ i) 29 { 30 cout << pThreadData->strThreadName << " --- " << i << endl; 31 Sleep(100); 32 } 33 return 0L; 34 } 35 36 int main() 37 { 38 //初始化线程数据 39 THREAD_DATA threadData1, threadData2; 40 threadData1.nMaxNum = 5; 41 strcpy(threadData1.strThreadName, "线程1"); 42 threadData2.nMaxNum = 10; 43 strcpy(threadData2.strThreadName, "线程2"); 44 45 //创建第一个子线程 46 HANDLE hThread1 = CreateThread(NULL, 0, ThreadProc, &threadData1, 0, NULL); 47 //创建第二个子线程 48 HANDLE hThread2 = CreateThread(NULL, 0, ThreadProc, &threadData2, 0, NULL); 49 //关闭线程 50 CloseHandle(hThread1); 51 CloseHandle(hThread2); 52 53 //主线程的执行路径 54 for (int i = 0; i < 5; ++ i) 55 { 56 cout << "主线程 === " << i << endl; 57 Sleep(100); 58 } 59 60 system("pause"); 61 return 0; 62 }
结果：
主线程 === 线程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++线程同步的处理，请看下一节。
在使用互斥量进行线程同步时会用到以下几个函数：
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的名称。
DWORD WINAPI WaitForSingleObject(
HANDLE hHandle, //要获取的锁的句柄
DWORD dwMilliseconds //超时间隔
);
**说明：**WaitForSingleObject的作用是等待一个指定的对象(如Mutex对象)，直到该对象处于非占用的状态(如Mutex对象被释放)或超出设定的时间间隔。除此之外，还有一个与它类似的函数WaitForMultipleObjects，它的作用是等待一个或所有指定的对象，直到所有的对象处于非占用的状态，或超出设定的时间间隔。
hHandle：要等待的指定对象的句柄。dwMilliseconds：超时的间隔，以毫秒为单位；如果dwMilliseconds为非0，则等待直到dwMilliseconds时间间隔用完或对象变为非占用的状态，如果dwMilliseconds 为INFINITE则表示无限等待，直到等待的对象处于非占用的状态。
BOOL WINAPI ReleaseMutex(HANDLE hMutex);
说明：释放所拥有的互斥量锁对象，hMutex为释放的互斥量的句柄。
【Demo3】：线程同步
1 #include "stdafx.h" 2 #include <windows.h> 3 #include <iostream> 4 5 #define NAME_LINE 40 6 7 //定义线程函数传入参数的结构体 8 typedef struct __THREAD_DATA 9 { 10 int nMaxNum; 11 char strThreadName[NAME_LINE]; 12 13 __THREAD_DATA() : nMaxNum(0) 14 { 15 memset(strThreadName, 0, NAME_LINE * sizeof(char)); 16 } 17 }THREAD_DATA; 18 19 HANDLE g_hMutex = NULL; //互斥量 20 21 //线程函数 22 DWORD WINAPI ThreadProc(LPVOID lpParameter) 23 { 24 THREAD_DATA* pThreadData = (THREAD_DATA*)lpParameter; 25 26 for (int i = 0; i < pThreadData->nMaxNum; ++ i) 27 { 28 //请求获得一个互斥量锁 29 WaitForSingleObject(g_hMutex, INFINITE); 30 cout << pThreadData->strThreadName << " --- " << i << endl; 31 Sleep(100); 32 //释放互斥量锁 33 ReleaseMutex(g_hMutex); 34 } 35 return 0L; 36 } 37 38 int main() 39 { 40 //创建一个互斥量 41 g_hMutex = CreateMutex(NULL, FALSE, NULL); 42 43 //初始化线程数据 44 THREAD_DATA threadData1, threadData2; 45 threadData1.nMaxNum = 5; 46 strcpy(threadData1.strThreadName, "线程1"); 47 threadData2.nMaxNum = 10; 48 strcpy(threadData2.strThreadName, "线程2"); 49 50 51 //创建第一个子线程 52 HANDLE hThread1 = CreateThread(NULL, 0, ThreadProc, &threadData1, 0, NULL); 53 //创建第二个子线程 54 HANDLE hThread2 = CreateThread(NULL, 0, ThreadProc, &threadData2, 0, NULL); 55 //关闭线程 56 CloseHandle(hThread1); 57 CloseHandle(hThread2); 58 59 //主线程的执行路径 60 for (int i = 0; i < 5; ++ i) 61 { 62 //请求获得一个互斥量锁 63 WaitForSingleObject(g_hMutex, INFINITE); 64 cout << "主线程 === " << i << endl; 65 Sleep(100); 66 //释放互斥量锁 67 ReleaseMutex(g_hMutex); 68 } 69 70 system("pause"); 71 return 0; 72 }
结果：
主线程 === 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】：模拟火车售票系统
SaleTickets.h :
1 #include "stdafx.h" 2 #include <windows.h> 3 #include <iostream> 4 #include <strstream> 5 #include <string> 6 7 using namespace std; 8 9 #define NAME_LINE 40 10 11 //定义线程函数传入参数的结构体 12 typedef struct __TICKET 13 { 14 int nCount; 15 char strTicketName[NAME_LINE]; 16 17 __TICKET() : nCount(0) 18 { 19 memset(strTicketName, 0, NAME_LINE * sizeof(char)); 20 } 21 }TICKET; 22 23 typedef struct __THD_DATA 24 { 25 TICKET* pTicket; 26 char strThreadName[NAME_LINE]; 27 28 __THD_DATA() : pTicket(NULL) 29 { 30 memset(strThreadName, 0, NAME_LINE * sizeof(char)); 31 } 32 }THD_DATA; 33 34 35 //基本类型数据转换成字符串 36 template<class T> 37 string convertToString(const T val) 38 { 39 string s; 40 std::strstream ss; 41 ss << val; 42 ss >> s; 43 return s; 44 } 45 46 //售票程序 47 DWORD WINAPI SaleTicket(LPVOID lpParameter);
SaleTickets.cpp ：
1 #include "stdafx.h" 2 #include <windows.h> 3 #include <iostream> 4 #include "SaleTickets.h" 5 6 using namespace std; 7 8 extern HANDLE g_hMutex; 9 10 //售票程序 11 DWORD WINAPI SaleTicket(LPVOID lpParameter) 12 { 13 14 THD_DATA* pThreadData = (THD_DATA*)lpParameter; 15 TICKET* pSaleData = pThreadData->pTicket; 16 while(pSaleData->nCount > 0) 17 { 18 //请求获得一个互斥量锁 19 WaitForSingleObject(g_hMutex, INFINITE); 20 if (pSaleData->nCount > 0) 21 { 22 cout << pThreadData->strThreadName << "出售第" << pSaleData->nCount -- << "的票,"; 23 if (pSaleData->nCount >= 0) { 24 cout << "出票成功!剩余" << pSaleData->nCount << "张票." << endl; 25 } else { 26 cout << "出票失败！该票已售完。" << endl; 27 } 28 } 29 Sleep(10); 30 //释放互斥量锁 31 ReleaseMutex(g_hMutex); 32 } 33 34 return 0L; 35 }
测试程序：
1 //售票系统 2 void Test2() 3 { 4 //创建一个互斥量 5 g_hMutex = CreateMutex(NULL, FALSE, NULL); 6 7 //初始化火车票 8 TICKET ticket; 9 ticket.nCount = 100; 10 strcpy(ticket.strTicketName, "北京-->赣州"); 11 12 const int THREAD_NUMM = 8; 13 THD_DATA threadSale[THREAD_NUMM]; 14 HANDLE hThread[THREAD_NUMM]; 15 for(int i = 0; i < THREAD_NUMM; ++ i) 16 { 17 threadSale[i].pTicket = &ticket; 18 string strThreadName = convertToString(i); 19 20 strThreadName = "窗口" + strThreadName; 21 22 strcpy(threadSale[i].strThreadName, strThreadName.c_str()); 23 24 //创建线程 25 hThread[i] = CreateThread(NULL, NULL, SaleTicket, &threadSale[i], 0, NULL); 26 27 //请求获得一个互斥量锁 28 WaitForSingleObject(g_hMutex, INFINITE); 29 cout << threadSale[i].strThreadName << "开始出售 " << threadSale[i].pTicket->strTicketName << " 的票..." << endl; 30 //释放互斥量锁 31 ReleaseMutex(g_hMutex); 32 33 //关闭线程 34 CloseHandle(hThread[i]); 35 } 36 37 system("pause"); 38 }
结果：
窗口0开始出售 北京–>赣州 的票…
窗口0出售第100的票,出票成功!剩余99张票.
窗口1开始出售 北京–>赣州 的票…
窗口1出售第99的票,出票成功!剩余98张票.
窗口0出售第98的票,出票成功!剩余97张票.
窗口2开始出售 北京–>赣州 的票…
窗口2出售第97的票,出票成功!剩余96张票.
窗口1出售第96的票,出票成功!剩余95张票.
窗口0出售第95的票,出票成功!剩余94张票.
窗口3开始出售 北京–>赣州 的票…
窗口3出售第94的票,出票成功!剩余93张票.
窗口2出售第93的票,出票成功!剩余92张票.
窗口1出售第92的票,出票成功!剩余91张票.
窗口0出售第91的票,出票成功!剩余90张票.
窗口4开始出售 北京–>赣州 的票…
窗口4出售第90的票,出票成功!剩余89张票.
窗口3出售第89的票,出票成功!剩余88张票.
窗口2出售第88的票,出票成功!剩余87张票.
窗口1出售第87的票,出票成功!剩余86张票.
窗口0出售第86的票,出票成功!剩余85张票.
窗口5开始出售 北京–>赣州 的票…
窗口5出售第85的票,出票成功!剩余84张票.
窗口4出售第84的票,出票成功!剩余83张票.
窗口3出售第83的票,出票成功!剩余82张票.
窗口2出售第82的票,出票成功!剩余81张票.
如果您有什么疑惑和想法，请在评论处给予反馈，您的反馈就是最好的测评师！由于本人技术和能力有限，如果本博文有错误或不足之处，敬请谅解并给出您宝贵的建议！
以上是关于多线程与多进程的主要内容，如果未能解决你的问题，请参考以下文章