Linux和windows进程同步与线程同步那些事儿（一）
Linux和windows进程同步与线程同步那些事儿（二）： windows线程同步详解示例
Linux和windows进程同步与线程同步那些事儿（三）： Linux线程同步详解示例
Linux和windows进程同步与线程同步那些事儿（四）：windows 下进程同步
Linux和windows进程同步与线程同步那些事儿（五）：Linux下进程同步
互斥量是最常用的线程同步机制，它可以确保在同一时间只有一个线程可以访问共享资源。
在Windows中，可以使用CreateMutex函数来创建互斥量。
下面是一个使用互斥量实现进程同步的代码示例。该示例展示了两个进程之间如何使用互斥量来保证共享资源的互斥访问。
#include <iostream>
#include <windows.h>
int main() {
// 创建互斥量对象
HANDLE hMutex = CreateMutex(NULL, FALSE, "MyMutex");
if (hMutex == NULL) {
std::cout << "互斥量创建失败！" << std::endl;
return 1;
}
// 尝试获取互斥量的所有权
DWORD dwWaitResult = WaitForSingleObject(hMutex, INFINITE);
if (dwWaitResult == WAIT_OBJECT_0) {
std::cout << "进程A获得了互斥量的所有权！" << std::endl;
// 模拟共享资源的访问
std::cout << "进程A正在访问共享资源..." << std::endl;
Sleep(5000);
// 释放互斥量的所有权
ReleaseMutex(hMutex);
std::cout << "进程A释放了互斥量的所有权！" << std::endl;
}
else {
std::cout << "进程A无法获取互斥量的所有权！" << std::endl;
}
// 关闭互斥量句柄
CloseHandle(hMutex);
return 0;
}
#include <iostream>
#include <windows.h>
int main() {
// 创建互斥量对象
HANDLE hMutex = CreateMutex(NULL, FALSE, "MyMutex");
if (hMutex == NULL) {
std::cout << "互斥量创建失败！" << std::endl;
return 1;
}
// 尝试获取互斥量的所有权
DWORD dwWaitResult = WaitForSingleObject(hMutex, INFINITE);
if (dwWaitResult == WAIT_OBJECT_0) {
std::cout << "进程B获得了互斥量的所有权！" << std::endl;
// 模拟共享资源的访问
std::cout << "进程B正在访问共享资源..." << std::endl;
Sleep(3000);
// 释放互斥量的所有权
ReleaseMutex(hMutex);
std::cout << "进程B释放了互斥量的所有权！" << std::endl;
}
else {
std::cout << "进程B无法获取互斥量的所有权！" << std::endl;
}
// 关闭互斥量句柄
CloseHandle(hMutex);
return 0;
}
在上面的代码示例中，进程A和进程B都通过调用CreateMutex函数来创建了一个名为"MyMutex"的互斥量对象。接着，它们分别调用WaitForSingleObject函数来尝试获取互斥量的所有权。
如果某个进程成功获取了互斥量的所有权（即dwWaitResult的值为WAIT_OBJECT_0），那么它就可以访问共享资源。在示例中，为了模拟共享资源的访问，我们使用了Sleep函数来暂停程序的执行。
完成对共享资源的访问后，进程需要调用ReleaseMutex函数来释放互斥量的所有权，以便其他进程可以获取互斥量的所有权。
最后，进程要调用CloseHandle函数来关闭互斥量句柄，释放系统资源。
请注意，这只是一个简单的示例，实际的应用中可能还需要处理异常情况、错误处理等。
事件用于线程间的通信和同步，允许线程等待某个特定事件的发生。
在Windows中，可以使用CreateEvent函数来创建事件对象。
下面是一个使用事件(Event)实现进程同步的代码示例。该示例展示了两个进程之间如何使用事件来进行进程同步。
#include <iostream>
#include <windows.h>
int main() {
// 创建事件对象
HANDLE hEvent = CreateEvent(NULL, FALSE, FALSE, "MyEvent");
if (hEvent == NULL) {
std::cout << "事件创建失败！" << std::endl;
return 1;
}
// 等待事件变为有信号状态
DWORD dwWaitResult = WaitForSingleObject(hEvent, INFINITE);
if (dwWaitResult == WAIT_OBJECT_0) {
std::cout << "进程A检测到事件有信号！" << std::endl;
// 执行需要同步的操作
std::cout << "进程A正在执行同步操作..." << std::endl;
Sleep(5000);
std::cout << "进程A完成同步操作！" << std::endl;
}
else {
std::cout << "进程A等待事件超时或发生其他错误！" << std::endl;
}
// 关闭事件句柄
CloseHandle(hEvent);
return 0;
}
#include <iostream>
#include <windows.h>
int main() {
// 打开事件对象
HANDLE hEvent = OpenEvent(EVENT_MODIFY_STATE, FALSE, "MyEvent");
if (hEvent == NULL) {
std::cout << "事件打开失败！" << std::endl;
return 1;
}
// 设置事件为有信号状态
if (SetEvent(hEvent)) {
std::cout << "进程B设置了事件的信号！" << std::endl;
}
else {
std::cout << "进程B设置事件的信号失败！" << std::endl;
}
// 关闭事件句柄
CloseHandle(hEvent);
return 0;
}
在上面的代码示例中，进程A通过调用CreateEvent函数来创建了一个名为"MyEvent"的事件对象。而进程B则通过调用OpenEvent函数来打开同一个事件对象。
进程A调用WaitForSingleObject函数来等待事件变为有信号状态。一旦事件有信号，进程A就可以执行需要同步的操作。在示例中，我们使用了Sleep函数来模拟同步操作的执行。
进程B在需要进行同步的时候，调用SetEvent函数来设置事件的信号。这样，进程A就会被唤醒，继续执行同步操作。
请注意，事件对象具有自动复位（auto-reset）的特性，即一旦某个等待事件的进程被唤醒，事件会自动重置为无信号状态，其他等待事件的进程将继续等待。
最后，进程要调用CloseHandle函数来关闭事件句柄，释放系统资源。
临界区用于保护共享资源，确保在同一时间只有一个线程可以访问。
在Windows中，可以使用InitializeCriticalSection函数来初始化临界区。
下面是一个使用临界区(Critical Section)实现进程同步的代码示例。该示例展示了两个进程之间如何使用临界区来进行进程同步。
#include <iostream>
#include <windows.h>
CRITICAL_SECTION g_cs; // 全局临界区对象
int main() {
// 初始化临界区
InitializeCriticalSection(&g_cs);
// 进入临界区
EnterCriticalSection(&g_cs);
std::cout << "进程A进入临界区，执行同步操作..." << std::endl;
Sleep(5000); // 模拟同步操作
std::cout << "进程A完成同步操作，退出临界区！" << std::endl;
// 离开临界区
LeaveCriticalSection(&g_cs);
// 销毁临界区
DeleteCriticalSection(&g_cs);
return 0;
}
#include <iostream>
#include <windows.h>
CRITICAL_SECTION g_cs; // 全局临界区对象
int main() {
// 初始化临界区
InitializeCriticalSection(&g_cs);
// 进入临界区
EnterCriticalSection(&g_cs);
std::cout << "进程B进入临界区，执行同步操作..." << std::endl;
Sleep(5000); // 模拟同步操作
std::cout << "进程B完成同步操作，退出临界区！" << std::endl;
// 离开临界区
LeaveCriticalSection(&g_cs);
// 销毁临界区
DeleteCriticalSection(&g_cs);
return 0;
}
在上面的代码示例中，我们使用CRITICAL_SECTION类型的全局变量g_cs作为临界区对象。
进程A和进程B都会初始化临界区对象，进入临界区进行同步操作。
在示例中，我们使用了Sleep函数来模拟同步操作的执行。
进程A和进程B在完成同步操作后，都需要离开临界区。
最后，进程要调用DeleteCriticalSection函数来销毁临界区对象，释放系统资源。
请注意，临界区是进程内的同步机制，不适用于跨进程的同步。如果需要跨进程的同步，可以考虑使用互斥量(Mutex)或事件(Event)等其他机制。
信号量是一种经典的线程同步机制，它可以用于控制对共享资源的访问。
在Windows中，可以使用CreateSemaphore函数来创建信号量。
下面是一个使用信号量(Semaphore)实现进程同步的代码示例。该示例展示了两个进程之间如何使用信号量来进行进程同步。
#include <iostream>
#include <windows.h>
HANDLE g_semaphore; // 全局信号量句柄
int main() {
// 创建一个信号量，初始值为0，用于进程同步
g_semaphore = CreateSemaphore(NULL, 0, 1, L"ProcessSync");
std::cout << "进程A执行同步操作..." << std::endl;
Sleep(5000); // 模拟同步操作
std::cout << "进程A完成同步操作，释放信号量！" << std::endl;
ReleaseSemaphore(g_semaphore, 1, NULL); // 释放信号量，允许进程B执行
// 关闭信号量句柄
CloseHandle(g_semaphore);
return 0;
}
#include <iostream>
#include <windows.h>
HANDLE g_semaphore; // 全局信号量句柄
int main() {
// 创建一个信号量，初始值为0，用于进程同步
g_semaphore = CreateSemaphore(NULL, 0, 1, L"ProcessSync");
// 进程B等待信号量，直到进程A释放信号量
WaitForSingleObject(g_semaphore, INFINITE);
std::cout << "进程B执行同步操作..." << std::endl;
Sleep(5000); // 模拟同步操作
std::cout << "进程B完成同步操作，释放信号量！" << std::endl;
ReleaseSemaphore(g_semaphore, 1, NULL); // 释放信号量，允许其他进程执行
// 关闭信号量句柄
CloseHandle(g_semaphore);
return 0;
}
在上面的示例代码中，我们使用了HANDLE类型的全局变量g_semaphore作为信号量句柄。
进程A创建了一个名为"ProcessSync"的信号量，并执行同步操作之后，调用ReleaseSemaphore函数释放信号量。
进程B在等待信号量状态下，调用WaitForSingleObject函数等待进程A释放信号量，然后执行同步操作。
最后，进程要调用CloseHandle函数来关闭信号量句柄，释放系统资源。
请注意，信号量是一种用于进程间同步的机制，可以在不同进程之间实现同步。在示例中，我们使用了一个简单的二进制信号量，它的初始值为0，进程A通过ReleaseSemaphore函数将其值设置为1，使进程B可以继续执行。
命名管道是一种进程间通信的机制，可以用于实现进程间的数据交换和同步。
在Windows中，可以使用CreateNamedPipe函数来创建命名管道。
在 Windows 下，可以使用命名管道（Named Pipe）实现多进程间的同步。命名管道是一种特殊的文件，用于在不同进程间进行通信。下面是一个使用命名管道实现多进程同步的 C++ 代码示例：
进程A：写入数据
#include <iostream>
#include <windows.h>
int main()
{
HANDLE hPipe;
// 创建命名管道
LPCWSTR pipeName = TEXT("\\\\.\\pipe\\my_pipe");
hPipe = CreateNamedPipe(
pipeName,
PIPE_ACCESS_DUPLEX,
PIPE_TYPE_MESSAGE | PIPE_WAIT,
1, // 最大实例数
65536, // 输出缓冲区大小
65536, // 输入缓冲区大小
0, // 默认超时时间
NULL // 安全属性
);
// 等待进程B连接
ConnectNamedPipe(hPipe, NULL);
// 向管道写入数据
const char* data = "Hello, World!";
DWORD bytesWritten;
WriteFile(hPipe, data, strlen(data) + 1, &bytesWritten, NULL);
// 关闭管道
DisconnectNamedPipe(hPipe);
CloseHandle(hPipe);
return 0;
}
进程B：读取数据
#include <iostream>
#include <windows.h>
int main()
{
HANDLE hPipe;
// 连接到命名管道
LPCWSTR pipeName = TEXT("\\\\.\\pipe\\my_pipe");
hPipe = CreateFile(
pipeName,
GENERIC_READ,
0, // 共享模式
NULL, // 安全属性
OPEN_EXISTING,
0, // 属性和标志
NULL // 模板文件
);
// 从管道读取数据
char buffer[65536];
DWORD bytesRead;
ReadFile(hPipe, buffer, sizeof(buffer), &bytesRead, NULL);
// 打印数据
std::cout << buffer << std::endl;
// 关闭管道
CloseHandle(hPipe);
return 0;
}
上述代码中，进程A创建了一个命名管道，并等待进程B连接。然后，它向管道写入数据。进程B连接到同一个命名管道，并读取进程A写入的数据。
让我们更详细地解释一下代码：
在进程A中，CreateNamedPipe 函数用于创建命名管道。参数 pipeName 指定了命名管道的名称，格式为 \\.\pipe\pipeName。其他参数设置了管道的访问权限、缓冲区大小等。
进程A调用 ConnectNamedPipe 函数等待进程B连接。
进程A使用 WriteFile 函数向管道写入数据。
进程B使用 CreateFile 函数连接到命名管道。
进程B调用 ReadFile 函数从管道中读取数据。
最后，进程B关闭了管道。
在实际使用中，可以根据需要对代码进行修改和扩展，以满足你的具体需求。例如，你可以使用多线程创建多个进程，或者通过命名管道进行双向通信。
共享内存允许多个进程访问同一块内存区域，从而实现进程间的数据共享和通信。
在Windows中，可以使用CreateFileMapping和MapViewOfFile等函数来创建和访问共享内存区域。
下面是一个使用共享内存在Windows下实现多个进程同步的代码示例：
#include <iostream>
#include <Windows.h>
// 共享内存结构体
struct SharedData {
HANDLE mutex; // 互斥量
HANDLE event; // 事件
CONDITION_VARIABLE conditionVariable; // 条件变量
int counter; // 共享计数器
};
int main() {
// 创建共享内存
HANDLE hMapFile = CreateFileMapping(
INVALID_HANDLE_VALUE,
nullptr,
PAGE_READWRITE,
0,
sizeof(SharedData),
L"MySharedMemory"
);
if (hMapFile == NULL) {
std::cerr << "Failed to create shared memory" << std::endl;
return 1;
}
// 获取共享内存指针
SharedData* sharedData = (SharedData*)MapViewOfFile(
hMapFile,
FILE_MAP_ALL_ACCESS,
0,
0,
sizeof(SharedData)
);
if (sharedData == NULL) {
std::cerr << "Failed to map shared memory" << std::endl;
CloseHandle(hMapFile);
return 1;
}
// 初始化互斥量、事件和条件变量
sharedData->mutex = CreateMutex(nullptr, FALSE, nullptr);
sharedData->event = CreateEvent(nullptr, FALSE, FALSE, nullptr);
InitializeConditionVariable(&sharedData->conditionVariable);
sharedData->counter = 0;
// 创建多个进程进行同步操作
for (int i = 0; i < 5; i++) {
STARTUPINFO si = {};
PROCESS_INFORMATION pi = {};
wchar_t cmdLine[] = L"ChildProcess.exe"; // 子进程程序名
// 启动子进程
if (!CreateProcess(
nullptr,
cmdLine,
nullptr,
nullptr,
FALSE,
0,
nullptr,
nullptr,
&si,
&pi
)) {
std::cerr << "Failed to create child process" << std::endl;
CloseHandle(hMapFile);
return 1;
}
// 关闭子进程句柄
CloseHandle(pi.hThread);
CloseHandle(pi.hProcess);
}
// 等待所有子进程执行完毕
WaitForMultipleObjects(5, sharedData->processHandles, TRUE, INFINITE);
// 输出计数器值
std::cout << "Counter = " << sharedData->counter << std::endl;
// 释放资源
UnmapViewOfFile(sharedData);
CloseHandle(sharedData->mutex);
CloseHandle(sharedData->event);
CloseHandle(hMapFile);
return 0;
}
这个示例中，首先创建了一个共享内存来存储互斥量、事件和条件变量等同步对象以及一个共享计数器。然后创建了多个子进程，在子进程中进行同步操作。
子进程代码示例（ChildProcess.exe）：
#include <iostream>
#include <Windows.h>
struct SharedData {
HANDLE mutex;
HANDLE event;
CONDITION_VARIABLE conditionVariable;
int counter;
};
int main() {
HANDLE hMapFile = OpenFileMapping(
FILE_MAP_ALL_ACCESS,
FALSE,
L"MySharedMemory"
);
if (hMapFile == NULL) {
std::cerr << "Failed to open shared memory" << std::endl;
return 1;
}
SharedData* sharedData = (SharedData*)MapViewOfFile(
hMapFile,
FILE_MAP_ALL_ACCESS,
0,
0,
sizeof(SharedData)
);
if (sharedData == NULL) {
std::cerr << "Failed to map shared memory" << std::endl;
CloseHandle(hMapFile);
return 1;
}
// 等待主进程通知
WaitForSingleObject(sharedData->event, INFINITE);
// 互斥量保护临界区
WaitForSingleObject(sharedData->mutex, INFINITE);
// 执行同步操作
sharedData->counter++;
std::cout << "Child process counter = " << sharedData->counter << std::endl;
// 离开临界区
ReleaseMutex(sharedData->mutex);
// 通知主进程完成
WakeConditionVariable(&sharedData->conditionVariable);
// 释放资源
UnmapViewOfFile(sharedData);
CloseHandle(hMapFile);
return 0;
}
在子进程中，首先打开共享内存，并获取共享内存指针。然后等待主进程通知，获取互斥量保护临界区，执行同步操作，离开临界区，通知主进程完成，并释放资源。
互斥量（mutex）：
适用场景：多个进程需要争夺同一个资源时，只能有一个进程访问资源。
优点：简单易用，能够实现多个进程间的互斥访问。
缺点：性能较低，需要进行系统调用，可能引起上下文切换开销。
事件（event）：
适用场景：多个进程需要等待某个特定事件的发生后才能继续执行。
优点：可以在多个进程之间进行高效的同步。
缺点：只能用于单个事件的同步，不能用于争夺资源的同步。
临界区（critical section）：
适用场景：多个进程需要访问共享资源时，只能有一个进程访问资源。
优点：具有较高的性能，适用于保护共享资源的场景。
缺点：只能用于同一个进程内的进程同步，不能用于跨进程同步。
信号量（semaphore）：
适用场景：多个进程需要访问有限数量的资源时，控制同时访问的进程数量。
优点：可以用于控制同时访问资源的进程数量。
缺点：较复杂，容易引发死锁问题。
命名管道（named pipe）：
适用场景：多个进程之间进行双向通信和同步。
优点：提供了进程间的可靠通信和同步机制。
缺点：性能较低，只能用于进程之间的通信和同步。
共享内存（shared memory）：
适用场景：多个进程需要共享大块数据时。
优点：高效的进程间通信，能够实现数据共享。
缺点：需要进行同步，容易引发数据不一致或竞态条件。
综合比较：
根据具体的场景和需求，可以选择合适的进程同步机制来实现进程间的同步和通信。