devbox
喵喵爱编程
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C/C++ 实现多线程与线程同步_c++多线程执行同一个函数

作者：喵喵爱编程 | 2024-08-13 00:00:39

赞

踩

c++多线程执行同一个函数

多线程中的线程同步可以使用，CreateThread，CreateMutex 互斥锁实现线程同步，通过临界区实现线程同步，Semaphore 基于信号实现线程同步，CreateEvent 事件对象的同步，以及线程函数传递单一参数与多个参数的实现方式。

CreateThread 实现多线程

先来创建一个简单的多线程实例，无参数传递版，运行实例会发现，主线程与子线程运行无规律。

  1. #include <windows.h>
  2. #include <iostream>
  3.  
  4. using namespace std;
  5.  
  6. DWORD WINAPI Func(LPVOID lpParamter)
  7. {
  8. 	for (int x = 0; x < 10; x++)
  9. 	{
  10. 		cout << "thread function" << endl;
  11. 		Sleep(200);
  12. 	}
  13. 	return 0;
  14. }
  15.  
  16. int main(int argc,char * argv[])
  17. {
  18. 	HANDLE hThread = CreateThread(NULL, 0, Func, NULL, 0, NULL);
  19. 	CloseHandle(hThread);
  20.  
  21. 	for (int x = 0; x < 10; x++)
  22. 	{
  23. 		cout << "main thread" << endl;
  24. 		Sleep(400);
  25. 	}
  26.  
  27. 	system("pause");
  28. 	return 0;
  29. }

beginthreadex 实现多线程

这个方法与前面的CreateThread使用完全一致，只是在参数上面应使用void *该参数可以强转为任意类型，两者实现效果完全一致。

  1. #include <windows.h>
  2. #include <iostream>
  3. #include <process.h>
  4.  
  5. using namespace std;
  6.  
  7. unsigned WINAPI Func(void *arg)
  8. {
  9. 	for (int x = 0; x < 10; x++)
  10. 	{
  11. 		cout << "thread function" << endl;
  12. 		Sleep(200);
  13. 	}
  14. 	return 0;
  15. }
  16.  
  17. int main(int argc, char * argv[])
  18. {
  19. 	HANDLE hThread = (HANDLE)_beginthreadex(NULL, 0, Func, NULL, 0, NULL);
  20. 	CloseHandle(hThread);
  21. 	for (int x = 0; x < 10; x++)
  22. 	{
  23. 		cout << "main thread" << endl;
  24. 		Sleep(400);
  25. 	}
  26.  
  27. 	system("pause");
  28. 	return 0;
  29. }

CreateMutex 互斥锁实现线程同步

使用互斥锁可以实现单位时间内，只允许一个线程拥有对共享资源的独占，从而实现了互不冲突的线程同步。

  1. #include <windows.h>
  2. #include <iostream>
  3.  
  4. using namespace std;
  5. HANDLE hMutex = NULL;   // 创建互斥锁
  6.  
  7. // 线程函数
  8. DWORD WINAPI Func(LPVOID lpParamter)
  9. {
  10. 	for (int x = 0; x < 10; x++)
  11. 	{
  12. 		// 请求获得一个互斥锁
  13. 		WaitForSingleObject(hMutex, INFINITE);
  14. 		cout << "thread func" << endl;
  15. 		// 释放互斥锁
  16. 		ReleaseMutex(hMutex);
  17. 	}
  18. 	return 0;
  19. }
  20.  
  21. int main(int argc,char * argv[])
  22. {
  23. 	HANDLE hThread = CreateThread(NULL, 0, Func, NULL, 0, NULL);
  24.  
  25. 	hMutex = CreateMutex(NULL, FALSE, "lyshark");
  26. 	CloseHandle(hThread);
  27.  
  28. 	for (int x = 0; x < 10; x++)
  29. 	{
  30. 		// 请求获得一个互斥锁
  31. 		WaitForSingleObject(hMutex, INFINITE);
  32. 		cout << "main thread" << endl;
  33. 		
  34. 		// 释放互斥锁
  35. 		ReleaseMutex(hMutex);
  36. 	}
  37. 	system("pause");
  38. 	return 0;
  39. }

通过互斥锁，同步执行两个线程函数。

  1. #include <windows.h>
  2. #include <iostream>
  3.  
  4. using namespace std;
  5. HANDLE hMutex = NULL;   // 创建互斥锁
  6. #define NUM_THREAD 50
  7.  
  8. // 线程函数1
  9. DWORD WINAPI FuncA(LPVOID lpParamter)
  10. {
  11. 	for (int x = 0; x < 10; x++)
  12. 	{
  13. 		// 请求获得一个互斥锁
  14. 		WaitForSingleObject(hMutex, INFINITE);
  15. 		cout << "this is thread func A" << endl;
  16. 		// 释放互斥锁
  17. 		ReleaseMutex(hMutex);
  18. 	}
  19. 	return 0;
  20. }
  21.  
  22. // 线程函数2
  23. DWORD WINAPI FuncB(LPVOID lpParamter)
  24. {
  25. 	for (int x = 0; x < 10; x++)
  26. 	{
  27. 		// 请求获得一个互斥锁
  28. 		WaitForSingleObject(hMutex, INFINITE);
  29. 		cout << "this is thread func B" << endl;
  30. 		// 释放互斥锁
  31. 		ReleaseMutex(hMutex);
  32. 	}
  33. 	return 0;
  34. }
  35.  
  36. int main(int argc, char * argv[])
  37. {
  38.  
  39. 	// 用来存储线程函数的句柄
  40. 	HANDLE tHandle[NUM_THREAD];
  41.  
  42. 	// /创建互斥量，此时为signaled状态
  43. 	hMutex = CreateMutex(NULL, FALSE, "lyshark");
  44.  
  45. 	for (int x = 0; x < NUM_THREAD; x++)
  46. 	{
  47. 		if (x % 2)
  48. 		{
  49. 			tHandle[x] = CreateThread(NULL, 0, FuncA, NULL, 0, NULL);
  50. 		}
  51. 		else
  52. 		{
  53. 			tHandle[x] = CreateThread(NULL, 0, FuncB, NULL, 0, NULL);
  54. 		}
  55. 	}
  56.  
  57. 	// 等待所有线程函数执行完毕
  58. 	WaitForMultipleObjects(NUM_THREAD, tHandle, TRUE, INFINITE);
  59. 	
  60. 	// 销毁互斥对象
  61. 	CloseHandle(hMutex);
  62.  
  63. 	system("pause");
  64. 	return 0;
  65. }

通过临界区实现线程同步

临界区与互斥锁差不多，临界区使用时会创建CRITICAL_SECTION临界区对象，同样相当于一把钥匙，线程函数执行结束自动上交，如下是临界区函数的定义原型。

  1. //初始化函数原型
  2. VOID InitializeCriticalSection(
  3.   LPCRITICAL_SECTION lpCriticalSection
  4. );
  5.  
  6. //销毁函数原型
  7. VOID DeleteCriticalSection(
  8.   LPCRITICAL_SECTION lpCriticalSection
  9. );
  10.  
  11. //获取
  12. VOID EnterCriticalSection(
  13.   LPCRITICAL_SECTION lpCriticalSection
  14. );
  15.  
  16. //释放
  17. VOID LeaveCriticalSection(  
  18.   LPCRITICAL_SECTION lpCriticalSection
  19. );

这一次我们不适用互斥体，使用临界区实现线程同步，结果与互斥体完全一致，看个人喜好。

  1. #include <windows.h>
  2. #include <iostream>
  3.  
  4. using namespace std;
  5. CRITICAL_SECTION cs;         // 全局定义临界区对象
  6. #define NUM_THREAD 50
  7.  
  8. // 线程函数
  9. DWORD WINAPI FuncA(LPVOID lpParamter)
  10. {
  11. 	for (int x = 0; x < 10; x++)
  12. 	{
  13. 		//进入临界区
  14. 		EnterCriticalSection(&cs);
  15.  
  16. 		cout << "this is thread func A" << endl;
  17.  
  18. 		//离开临界区
  19. 		LeaveCriticalSection(&cs);
  20.  
  21. 	}
  22. 	return 0;
  23. }
  24.  
  25. int main(int argc, char * argv[])
  26. {
  27. 	// 用来存储线程函数的句柄
  28. 	HANDLE tHandle[NUM_THREAD];
  29.  
  30. 	//初始化临界区
  31. 	InitializeCriticalSection(&cs);
  32.  
  33. 	for (int x = 0; x < NUM_THREAD; x++)
  34. 	{
  35. 		tHandle[x] = CreateThread(NULL, 0, FuncA, NULL, 0, NULL);
  36. 	}
  37.  
  38. 	// 等待所有线程函数执行完毕
  39. 	WaitForMultipleObjects(NUM_THREAD, tHandle, TRUE, INFINITE);
  40. 	
  41. 	//释放临界区
  42. 	DeleteCriticalSection(&cs);
  43.  
  44. 	system("pause");
  45. 	return 0;
  46. }

Semaphore 基于信号实现线程同步

通过定义一个信号，初始化信号为0，利用信号量值为0时进入non-signaled状态，大于0时进入signaled状态的特性即可实现线程同步。

  1. #include <windows.h>
  2. #include <iostream>
  3.  
  4. using namespace std;
  5.  
  6. static HANDLE SemaphoreOne;
  7. static HANDLE SemaphoreTwo;
  8.  
  9. // 线程函数1
  10. DWORD WINAPI FuncA(LPVOID lpParamter)
  11. {
  12. 	for (int x = 0; x < 10; x++)
  13. 	{
  14. 		// 临界区开始时设置 signaled 状态
  15. 		WaitForSingleObject(SemaphoreOne, INFINITE);
  16.  
  17. 		cout << "this is thread func A" << endl;
  18.  
  19. 		// 临界区结束则设置为 non-signaled 状态
  20. 		ReleaseSemaphore(SemaphoreOne, 1, NULL);
  21. 	}
  22. 	return 0;
  23. }
  24.  
  25. // 线程函数2
  26. DWORD WINAPI FuncB(LPVOID lpParamter)
  27. {
  28. 	for (int x = 0; x < 10; x++)
  29. 	{
  30. 		// 临界区开始时设置 signaled 状态
  31. 		WaitForSingleObject(SemaphoreTwo, INFINITE);
  32.  
  33. 		cout << "this is thread func B" << endl;
  34.  
  35. 		// 临界区结束则设置为 non-signaled 状态
  36. 		ReleaseSemaphore(SemaphoreTwo, 1, NULL);
  37. 	}
  38. 	return 0;
  39. }
  40.  
  41. int main(int argc, char * argv[])
  42. {
  43. 	// 用来存储线程函数的句柄
  44. 	HANDLE hThreadA, hThreadB;
  45.  
  46. 	// 创建信号量对象,并且设置为0进入non-signaled状态 
  47. 	SemaphoreOne = CreateSemaphore(NULL, 0, 1, NULL);
  48.  
  49. 	// 创建信号量对象，并且设置为1进入signaled状态
  50. 	SemaphoreTwo = CreateSemaphore(NULL, 1, 1, NULL);       // 先执行这一个线程函数
  51.  
  52. 	hThreadA = CreateThread(NULL, 0, FuncA, NULL,0, NULL);
  53. 	hThreadB = CreateThread(NULL, 0, FuncB, NULL, 0, NULL);
  54.  
  55. 	// 等待两个线程函数执行完毕
  56. 	WaitForSingleObject(hThreadA, INFINITE);
  57. 	WaitForSingleObject(hThreadA, INFINITE);
  58.  
  59. 	// 销毁两个线程函数
  60. 	CloseHandle(SemaphoreOne);
  61. 	CloseHandle(SemaphoreTwo);
  62.  
  63. 	system("pause");
  64. 	return 0;
  65. }

上面的一段代码，容易产生死锁现象，即，线程函数B执行完成后，A函数一直处于等待状态。

执行WaitForSingleObject(semTwo, INFINITE);会让线程函数进入类似挂起的状态，当接到ReleaseSemaphore(semOne, 1, NULL);才会恢复执行。

  1. #include <windows.h>  
  2. #include <stdio.h>  
  3.  
  4. static HANDLE semOne,semTwo;
  5. static int num;
  6.  
  7. // 线程函数A用于接收参书
  8. DWORD WINAPI ReadNumber(LPVOID lpParamter)
  9. {
  10. 	int i;
  11. 	for (i = 0; i < 5; i++)
  12. 	{
  13. 		fputs("Input Number: ", stdout);
  14. 		//临界区的开始 signaled状态  
  15. 		WaitForSingleObject(semTwo, INFINITE);
  16. 		
  17. 		scanf("%d", &num);
  18.  
  19. 		//临界区的结束 non-signaled状态  
  20. 		ReleaseSemaphore(semOne, 1, NULL);
  21. 	}
  22. 	return 0;
  23. }
  24.  
  25. // 线程函数B: 用户接受参数后完成计算
  26. DWORD WINAPI Check(LPVOID lpParamter)
  27. {
  28. 	int sum = 0, i;
  29. 	for (i = 0; i < 5; i++)
  30. 	{
  31. 		//临界区的开始 non-signaled状态  
  32. 		WaitForSingleObject(semOne, INFINITE);
  33. 		sum += num;
  34. 		//临界区的结束 signaled状态  
  35. 		ReleaseSemaphore(semTwo, 1, NULL);
  36. 	}
  37. 	printf("The Number IS: %d \n", sum);
  38. 	return 0;
  39. }
  40.  
  41. int main(int argc, char *argv[])
  42. {
  43. 	HANDLE hThread1, hThread2;
  44.  
  45. 	//创建信号量对象,设置为0进入non-signaled状态  
  46. 	semOne = CreateSemaphore(NULL, 0, 1, NULL);
  47.  
  48. 	//创建信号量对象，设置为1进入signaled状态  
  49. 	semTwo = CreateSemaphore(NULL, 1, 1, NULL);
  50.  
  51. 	hThread1 = CreateThread(NULL, 0, ReadNumber, NULL, 0, NULL);
  52. 	hThread2 = CreateThread(NULL, 0, Check, NULL, 0, NULL);
  53.  
  54. 	// 关闭临界区
  55. 	WaitForSingleObject(hThread1, INFINITE);
  56. 	WaitForSingleObject(hThread2, INFINITE);
  57.  
  58. 	CloseHandle(semOne);
  59. 	CloseHandle(semTwo);
  60.  
  61. 	system("pause");
  62. 	return 0;
  63. }

CreateEvent 事件对象的同步

事件对象实现线程同步，与前面的临界区和互斥体有很大的不同，该方法下创建对象时，可以在自动non-signaled状态运行的auto-reset模式，当我们设置好我们需要的参数时，可以直接使用SetEvent(hEvent)设置事件状态，会自动执行线程函数。

  1. #include <windows.h>  
  2. #include <stdio.h>  
  3. #include <process.h>  
  4. #define STR_LEN 100  
  5.  
  6. // 存储全局字符串
  7. static char str[STR_LEN];
  8.  
  9. // 设置事件句柄
  10. static HANDLE hEvent;
  11.  
  12. // 统计字符串中是否存在A
  13. unsigned WINAPI NumberOfA(void *arg)
  14. {
  15. 	int cnt = 0;
  16. 	// 等待线程对象事件
  17. 	WaitForSingleObject(hEvent, INFINITE);
  18. 	for (int i = 0; str[i] != 0; i++)
  19. 	{
  20. 		if (str[i] == 'A')
  21. 			cnt++;
  22. 	}
  23. 	printf("Num of A: %d \n", cnt);
  24. 	return 0;
  25. }
  26.  
  27. // 统计字符串总长度
  28. unsigned WINAPI NumberOfOthers(void *arg)
  29. {
  30. 	int cnt = 0;
  31. 	// 等待线程对象事件
  32. 	WaitForSingleObject(hEvent, INFINITE);
  33. 	for (int i = 0; str[i] != 0; i++)
  34. 	{
  35. 		if (str[i] != 'A')
  36. 			cnt++;
  37. 	}
  38. 	printf("Num of others: %d \n", cnt - 1);
  39. 	return 0;
  40. }
  41.  
  42. int main(int argc, char *argv[])
  43. {
  44. 	HANDLE hThread1, hThread2;
  45.  
  46. 	// 以non-signaled创建manual-reset模式的事件对象
  47. 	// 该对象创建后不会被立即执行，只有我们设置状态为Signaled时才会继续
  48. 	hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
  49.  
  50. 	hThread1 = (HANDLE)_beginthreadex(NULL, 0, NumberOfA, NULL, 0, NULL);
  51. 	hThread2 = (HANDLE)_beginthreadex(NULL, 0, NumberOfOthers, NULL, 0, NULL);
  52.  
  53. 	fputs("Input string: ", stdout);
  54. 	fgets(str, STR_LEN, stdin);
  55.  
  56. 	// 字符串读入完毕后，将事件句柄改为signaled状态  
  57. 	SetEvent(hEvent);
  58.  
  59. 	WaitForSingleObject(hThread1, INFINITE);
  60. 	WaitForSingleObject(hThread2, INFINITE);
  61.  
  62. 	//non-signaled 如果不更改，对象继续停留在signaled
  63. 	ResetEvent(hEvent);
  64.  
  65. 	CloseHandle(hEvent);
  66.  
  67. 	system("pause");
  68. 	return 0;
  69. }

线程函数传递单个参数

线程函数中的定义中LPVOID允许传递一个参数，只需要在县城函数中接收并强转(int)(LPVOID)port即可。

  1. #include <stdio.h>
  2. #include <Windows.h>
  3.  
  4. // 线程函数接收一个参数
  5. DWORD WINAPI ScanThread(LPVOID port)
  6. {
  7. 	// 将参数强制转化为需要的类型
  8. 	int Port = (int)(LPVOID)port;
  9. 	printf("[+] 端口: %5d \n", port);
  10. 	return 1;
  11. }
  12.  
  13. int main(int argc, char* argv[])
  14. {
  15. 	HANDLE handle;
  16.  
  17. 	for (int port = 0; port < 100; port++)
  18. 	{
  19. 		handle = CreateThread(NULL, 0, (LPTHREAD_START_ROUTINE)ScanThread, (LPVOID)port, 0, 0);
  20. 	}
  21. 	WaitForSingleObject(handle, INFINITE);
  22.  
  23. 	system("pause");
  24. 	return 0;
  25. }

线程函数传递多参数

如果想在线程函数中传递多个参数，则需要传递一个结构指针，通过线程函数内部强转为结构类型后，取值，这个案例花费了我一些时间，网上也没找到合适的解决方法，或找到的都是歪瓜裂枣瞎转的东西，最后还是自己研究了一下写了一个没为题的。

其主要是线程函数中调用的参数会与下一个线程函数结构相冲突，解决的办法时在每次进入线程函数时，自己拷贝一份，每个人使用自己的那一份，才可以避免此类事件的发生，同时最好配合线程同步一起使用，如下时线程扫描器的部分代码片段。

  1. #include <stdio.h>
  2. #include <windows.h>
  3.  
  4. typedef struct _THREAD_PARAM
  5. {
  6. 	char *HostAddr;             // 扫描主机
  7. 	DWORD dwStartPort;          // 端口号
  8. }THREAD_PARAM;
  9.  
  10.  
  11. // 这个扫描线程函数
  12. DWORD WINAPI ScanThread(LPVOID lpParam)
  13. {
  14. 	// 拷贝传递来的扫描参数
  15. 	THREAD_PARAM ScanParam = { 0 };
  16.  
  17. 	// 这一步很重要，如不拷贝，则会发生重复赋值现象，导致扫描端口一直都是一个。
  18. 	// 坑死人的玩意，一开始我始终没有发现这个问题。sb玩意！！
  19. 	MoveMemory(&ScanParam, lpParam, sizeof(THREAD_PARAM));
  20.  
  21. 	printf("地址: %-16s --> 端口: %-5d 状态: [Open] \n", ScanParam.HostAddr, ScanParam.dwStartPort);
  22. 	return 0;
  23. }
  24.  
  25. int main(int argc, char *argv[])
  26. {
  27. 	THREAD_PARAM ThreadParam = { 0 };
  28. 	ThreadParam.HostAddr = "192.168.1.10";
  29.  
  30. 	for (DWORD port = 1; port < 100; port++)
  31. 	{
  32. 		ThreadParam.dwStartPort = port;
  33. 		HANDLE hThread = CreateThread(NULL, 0, ScanThread, (LPVOID)&ThreadParam, 0, NULL);
  34. 		WaitForSingleObject(hThread, INFINITE);
  35. 	}
  36.  
  37. 	system("pause");
  38. 	return 0;
  39. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/喵喵爱编程/article/detail/972178
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号