• windows系统编程1——线程和进程

    学习视频链接

    03进程的创建_哔哩哔哩_bilibilihttps://www.bilibili.com/video/BV1Fd4y1G7Td?p=3&vd_source=0471cde1c644648fafd07b54e303c905

    目录

    一、创建线程

    二、线程间同步

    2.1  线程不同步的结果

    2.2 原子操作上锁

    2.3 临界区

    2.4 内核对象

    三、线程间通信

    四、进程的创建

    五、进程间通信

    5.1 通信方式分类

    5.2  共享内存的写法

    一、创建线程

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5.  
    6. // 回调函数
    7. DWORD WINAPI ThreadProc(PVOID lp) 
    8. {
    9. 	int i = 0;
    10. 	while (i < 10) {
    11. 		Sleep(200);
    12. 		i++;
    13. 		printf("SubThread: %d\n", i);
    14. 	}
    15. 	return 0;
    16. }
    17.  
    18. int main()
    19. {
    20. 	//CreateThread(NULL, 0, ThreadProc, 0, 0, 0);                         // 创建，不开启线程
    21. 	HANDLE h = CreateThread(NULL, 0, ThreadProc, 0, CREATE_SUSPENDED, 0); // 创建，开启线程
    22. 	int i = 10;
    23. 	while (i < 20) {
    24. 		Sleep(200);
    25. 		i++;
    26. 		printf("ParentThread: %d\n", i);
    27. 	}
    28.  
    29. 	ResumeThread(h);  // 开启线程
    30.  
    31. 	Sleep(3000);
    32.  
    33. 	return 0;
    34. }

    h 代表句柄

    如果关闭两次线程就需要开启两次线程

    二、线程间同步

    2.1  线程不同步的结果

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5.  
    6. int g = 0;
    7.  
    8. // 回调函数
    9. DWORD WINAPI ThreadProc(PVOID lp)
    10. {
    11. 	for (int i = 0; i < 1000000; i++) {
    12. 		g++;
    13. 	}
    14. 	return 0;
    15. }
    16.  
    17. int main()
    18. {
    19. 	HANDLE h = CreateThread(NULL, 0, ThreadProc, 0, 0, 0);
    20. 	for (int i = 0; i < 1000000; i++) {
    21. 		g++;
    22. 	}
    23. 	WaitForSingleObject(h, INFINITE);  // 无限等待
    24. 	printf("%d\n", g);
    25. 	CloseHandle(h);  // 关闭线程
    26.  
    27. 	return 0;
    28. }

    子线程和主线程可能同时写主线程，导致不能够达到预期的 2000000

    2.2 原子操作上锁

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5.  
    6. unsigned int g = 0;
    7.  
    8. // 回调函数
    9. DWORD WINAPI ThreadProc(PVOID lp) 
    10. {
    11. 	for (int i = 0; i < 1000000; i++) {
    12. 		InterlockedIncrement(&g);
    13. 	}
    14. 	return 0;
    15. }
    16.  
    17. int main()
    18. {
    19. 	HANDLE h = CreateThread(NULL, 0, ThreadProc, 0, 0, 0);
    20. 	for (int i = 0; i < 1000000; i++) {
    21. 		InterlockedIncrement(&g);
    22. 	}
    23. 	WaitForSingleObject(h, INFINITE);  // 无限等待
    24. 	printf("%d\n", g);
    25. 	CloseHandle(h);  // 关闭线程
    26.  
    27. 	return 0;
    28. }

    2.3 临界区

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5.  
    6. int g = 0;
    7. CRITICAL_SECTION g_sec;  // 创建临界区对象
    8.  
    9. // 回调函数
    10. DWORD WINAPI ThreadProc(PVOID lp)
    11. {
    12. 	for (int i = 0; i < 100000; i++) {
    13. 		EnterCriticalSection(&g_sec);  // 进入临界区
    14. 		g++;
    15. 		LeaveCriticalSection(&g_sec);
    16. 	}
    17. 	return 0;
    18. }
    19.  
    20. int main()
    21. {
    22. 	// 初始化临界区对象
    23. 	InitializeCriticalSection(&g_sec);
    24. 	HANDLE h = CreateThread(0, 0, ThreadProc, 0, 0, 0);
    25. 	for (int i = 0; i < 100000; i++) {
    26. 		EnterCriticalSection(&g_sec);
    27. 		g++;
    28. 		LeaveCriticalSection(&g_sec);
    29. 	}
    30. 	WaitForSingleObject(h, INFINITE);           // 无限等待线程执行完
    31. 	printf("%d\n", g);
    32.  
    33. 	// 句柄释放
    34. 	CloseHandle(h);
    35.  
    36. 	return 0;
    37. }

    2.4 内核对象

    1、内核对象

    每一个内核对象在任何时候都处于两种状态之一：信号态和无信号态

    线程在等待其中的一个或多个内核对象时，如果在等待的一个或多个内核对象处于无信号态，线程自身将被系统挂起，直到等待的内核对象变为有信号状态时，线程才恢复运行。常用的等待函数有 2 个

    2、等待线程函数

    在多线程下面，有时候我们会希望等待某一线程完成了再继续做其他事情，要实现这个目的，可以使用 Windows API 函数 WaitForSingleObject，或者 WaitForMultipleObjects。这两个函数都会等待 Object 被标为有信号时才返回的。这两个函数的优点是它们在等待的过程中会进入一个非常高效沉睡状态，只占用极少的 CPU 时间片

    (1) 信号

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5.  
    6. int g = 0;
    7. HANDLE hmutex;
    8.  
    9. // 回调函数
    10. DWORD WINAPI ThreadProc(PVOID lp)
    11. {
    12. 	for (int i = 0; i < 100000; i++) {
    13. 		WaitForSingleObject(hmutex, INFINITE);  // hmutex 有信号->无信号
    14. 		g++;
    15. 		ReleaseMutex(hmutex);                   // hmutex 无信号->有信号
    16. 	}
    17. 	return 0;
    18. }
    19.  
    20. int main()
    21. {
    22. 	// 创建内核对象
    23. 	hmutex = CreateMutex(NULL, FALSE, NULL);   // hmutex 创建->有信号
    24. 	HANDLE h = CreateThread(NULL, 0, ThreadProc, 0, 0, 0);
    25. 	for (int i = 0; i < 100000; i++) {
    26. 		WaitForSingleObject(hmutex, INFINITE);  // hmutex 有信号->无信号
    27. 		g++;
    28. 		ReleaseMutex(hmutex);                   // hmutex 无信号->有信号
    29. 	}
    30. 	WaitForSingleObject(h, INFINITE);           // 无限等待线程执行完
    31. 	printf("%d\n", g);
    32.  
    33. 	// 释放内核释放
    34. 	CloseHandle(h);
    35. 	CloseHandle(hmutex);
    36.  
    37. 	return 0;
    38. }

    (2) 事件

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5.  
    6. int g = 0;
    7. HANDLE hEvent;
    8.  
    9. // 回调函数
    10. DWORD WINAPI ThreadProc(PVOID lp)
    11. {
    12. 	for (int i = 0; i < 100000; i++) {
    13. 		WaitForSingleObject(hEvent, INFINITE);  // hmutex 有事件->无事件
    14. 		g++;
    15. 		SetEvent(hEvent);                       // hmutex 无事件->有事件
    16. 	}
    17. 	return 0;
    18. }
    19.  
    20. int main()
    21. {
    22. 	// 创建事件对象
    23. 	hEvent = CreateEvent(NULL, FALSE, TRUE, NULL);
    24. 	HANDLE h = CreateThread(NULL, 0, ThreadProc, 0, 0, 0);
    25. 	for (int i = 0; i < 100000; i++) {
    26. 		WaitForSingleObject(hEvent, INFINITE);  // hmutex 有事件->无事件
    27. 		g++;
    28. 		SetEvent(hEvent);                       // hmutex 无事件->有事件
    29. 	}
    30. 	WaitForSingleObject(h, INFINITE);           // 无限等待线程执行完
    31. 	printf("%d\n", g);
    32.  
    33. 	// 释放内核释放
    34. 	CloseHandle(h);
    35. 	CloseHandle(hEvent);
    36.  
    37. 	return 0;
    38. }

    三、线程间通信

    1、使用全局变量进行通信

    2、参数传递方式

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5.  
    6. struct node {
    7. 	int age;
    8. 	int id;
    9. };
    10.  
    11. int g = 0;
    12. HANDLE hEvent;
    13.  
    14. // 回调函数
    15. DWORD WINAPI ThreadProc(PVOID lp)
    16. {
    17. 	node n = *(node*)lp;
    18. 	cout << n.age << " " << n.id << endl;;
    19. 	for (int i = 0; i < 100000; i++) {
    20. 		WaitForSingleObject(hEvent, INFINITE);  // hmutex 有事件->无事件
    21. 		g++;
    22. 		SetEvent(hEvent);                       // hmutex 无事件->有事件
    23. 	}
    24. 	return 0;
    25. }
    26.  
    27.  
    28.  
    29. int main()
    30. {
    31. 	node n;
    32. 	n.id = 1;
    33. 	n.age = 10;
    34. 	// 创建事件对象
    35. 	hEvent = CreateEvent(NULL, FALSE, TRUE, NULL);
    36. 	HANDLE h = CreateThread(NULL, 0, ThreadProc, &n, 0, 0);
    37. 	for (int i = 0; i < 100000; i++) {
    38. 		WaitForSingleObject(hEvent, INFINITE);  // hmutex 有事件->无事件
    39. 		g++;
    40. 		SetEvent(hEvent);                       // hmutex 无事件->有事件
    41. 	}
    42. 	WaitForSingleObject(h, INFINITE);           // 无限等待线程执行完
    43. 	printf("%d\n", g);
    44.  
    45. 	// 释放内核释放
    46. 	CloseHandle(h);
    47. 	CloseHandle(hEvent);
    48.  
    49. 	return 0;
    50. }

    3、消息传递方式

    MFC 里面的

    四、进程的创建

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5.  
    6. int main()
    7. {
    8. 	TCHAR commandLine[] = TEXT("C:/Program Files (x86)/Microsoft/Edge/Application/msedge.exe www.baidu.com");
    9. 	_STARTUPINFOW startInfo = { sizeof(_STARTUPINFOW)};
    10. 	_PROCESS_INFORMATION processInfo;
    11. 	/*
    12. 	BOOL CreateProcess(  
    13. 　		LPCTSTR               lpApplicationName,   应用程序名称  
    14. 　		LPTSTR                lpCommandLine,       命令行字符串  
    15. 　		LPSECURITY_ATTRIBUTES lpProcessAttributes, 进程的安全属性  
    16. 　		LPSECURITY_ATTRIBUTES lpThreadAttributes,  线程的安全属性  
    17. 　		BOOL                  bInheritHandles,     是否继承父进程的属性  
    18. 　		DWORD                 dwCreationFlags,     创建标志  
    19. 　		LPVOID                lpEnvironment,       指向新的环境块(环境变量)的指针  
    20. 　		LPCTSTR               lpCurrentDirectory,  指向当前目录名的指针  
    21. 　		LPSTARTUPINFO         lpStartupInfo,       传递给新进程的信息  
    22. 　		LPPROCESS_INFORMATION lpProcessInformation 新进程返回的信息  
    23. 	);
    24. 	*/
    25. 	bool ret = CreateProcess(NULL, commandLine, NULL, NULL, FALSE, 0, NULL, NULL, &startInfo, &processInfo);
    26.  
    27. 	if (ret == false) {
    28. 		cout << "创建进程失败" << endl;
    29. 		return 0;
    30. 	}
    31. 	else {
    32. 		WaitForSingleObject(processInfo.hProcess, INFINITE);
    33. 		cout << "新创建的进程ID: " << processInfo.dwProcessId << endl;
    34. 		cout << "新创建的线程ID: " << processInfo.dwThreadId  << endl;
    35. 		CloseHandle(processInfo.hProcess);
    36. 		CloseHandle(processInfo.hThread);
    37. 	}
    38.  
    39. 	return 0;
    40. }

    上述代码就完成了打开浏览器进程的任务了

     

    五、进程间通信

    5.1 通信方式分类

    >套接字(socket):

    套接字也是一种进程间通信机制，与其他通信机制不同的是，它可用于不同机器间的进程通信。

    5.2  共享内存的写法

    输出字符的程序

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5.  
    6. int main()
    7. {
    8. 	/*
    9. 	HANDLE CreateFileMapping(
    10. 		HANDLE hFile,                       // 物理文件句柄
    11. 		LPSECURITY_ATTRIBUTES lpAttributes, // 安全设置
    12. 		DWORD flProtect,                    // 保护设置
    13. 		DWORD dwMaximumSizeHigh,            // 高位文件大小
    14. 		DWORD dwMaximumSizeLow,             // 低位文件大小
    15. 		LPCTSTR lpName                      // 共享内存名称
    16. 	);
    17. 	*/
    18. 	// 创建共享文件句柄
    19. 	HANDLE hMapFile = CreateFileMapping(NULL, NULL, PAGE_READWRITE, 0, 1024, TEXT("fileMap"));
    20. 	char *buf = (char*)MapViewOfFile(hMapFile, FILE_MAP_ALL_ACCESS, 0, 0, 1024);
    21.  
    22. 	gets_s(buf, 100);
    23.  
    24. 	while (1) {
    25. 		Sleep(1000);
    26. 	}
    27. 	UnmapViewOfFile(buf);
    28. 	CloseHandle(hMapFile);
    29.  
    30. 	return 0;
    31. }

    接收字符的程序

    1. #include 
    2. #include 
    3.  
    4. using namespace std;
    5.  
    6. int main()
    7. {
    8. 	/*
    9. 	HANDLE CreateFileMapping(
    10. 		HANDLE hFile,                       // 物理文件句柄
    11. 		LPSECURITY_ATTRIBUTES lpAttributes, // 安全设置
    12. 		DWORD flProtect,                    // 保护设置
    13. 		DWORD dwMaximumSizeHigh,            // 高位文件大小
    14. 		DWORD dwMaximumSizeLow,             // 低位文件大小
    15. 		LPCTSTR lpName                      // 共享内存名称
    16. 	);
    17. 	*/
    18. 	// 创建共享文件句柄
    19. 	HANDLE hMapFile = CreateFileMapping(NULL, NULL, PAGE_READWRITE, 0, 1024, TEXT("fileMap"));
    20. 	char *buf = (char*)MapViewOfFile(hMapFile, FILE_MAP_ALL_ACCESS, 0, 0, 1024);
    21.  
    22. 	cout << buf << endl;
    23.  
    24. 	getchar();
    25. 	UnmapViewOfFile(buf);
    26. 	CloseHandle(hMapFile);
    27.  
    28. 	return 0;
    29. }

  • 相关阅读:
    Leetcode1106：解析布尔表达式
    JavaScript变量和作用域简介
    优化理论12---- 既约梯度法
    亚马逊云科技Glue
    SpringBoot事务失效场景、事务正确使用姿势
    线性表的线性表示；初始化，输出，插入，删除，查找；
    【2024秋招】2023-10-9 同花顺后端笔试题
    window-linux文件备份
    Js 对于一个时间戳，只改变其年份，求改变之后的时间戳。
    C#调用C++ dll 返回数组
  • 原文地址：https://blog.csdn.net/HuanBianCheng27/article/details/126808312