Linux和windows进程同步与线程同步那些事儿（四）：windows 下进程同步

已于 2024-01-11 11:01:48 修改
阅读量869 收藏 18
点赞数 18
分类专栏： # windows 文章标签： windows 编程语言 C++ 进程同步
于 2024-01-10 14:54:11 首次发布
本文为博主原创文章，未经博主允许不得转载。
本文链接：https://blog.csdn.net/weixin_39568531/article/details/135502868
版权

Linux和windows进程同步与线程同步那些事儿（一）
Linux和windows进程同步与线程同步那些事儿（二）： windows线程同步详解示例
Linux和windows进程同步与线程同步那些事儿（三）： Linux线程同步详解示例
Linux和windows进程同步与线程同步那些事儿（四）：windows 下进程同步
Linux和windows进程同步与线程同步那些事儿（五）：Linux下进程同步

1. 互斥量（Mutex）：

互斥量是最常用的线程同步机制，它可以确保在同一时间只有一个线程可以访问共享资源。
在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函数来关闭互斥量句柄，释放系统资源。

请注意，这只是一个简单的示例，实际的应用中可能还需要处理异常情况、错误处理等。

2. 事件（Event）：

事件用于线程间的通信和同步，允许线程等待某个特定事件的发生。
在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函数来关闭事件句柄，释放系统资源。

3. 临界区（Critical Section）：

临界区用于保护共享资源，确保在同一时间只有一个线程可以访问。
在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)等其他机制。

4. 信号量（Semaphore）：

信号量是一种经典的线程同步机制，它可以用于控制对共享资源的访问。
在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可以继续执行。

5. 命名管道（Named Pipe）：

命名管道是一种进程间通信的机制，可以用于实现进程间的数据交换和同步。
在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写入的数据。

让我们更详细地解释一下代码：

  1. 在进程A中，CreateNamedPipe 函数用于创建命名管道。参数 pipeName 指定了命名管道的名称，格式为 \\.\pipe\pipeName。其他参数设置了管道的访问权限、缓冲区大小等。

  2. 进程A调用 ConnectNamedPipe 函数等待进程B连接。

  3. 进程A使用 WriteFile 函数向管道写入数据。

  4. 进程B使用 CreateFile 函数连接到命名管道。

  5. 进程B调用 ReadFile 函数从管道中读取数据。

  6. 最后，进程B关闭了管道。

在实际使用中，可以根据需要对代码进行修改和扩展，以满足你的具体需求。例如，你可以使用多线程创建多个进程，或者通过命名管道进行双向通信。

6. 共享内存（Shared Memory）：

共享内存允许多个进程访问同一块内存区域，从而实现进程间的数据共享和通信。
在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）：
适用场景：多个进程需要共享大块数据时。
优点：高效的进程间通信，能够实现数据共享。
缺点：需要进行同步，容易引发数据不一致或竞态条件。

综合比较：

  • 互斥量 : 适用于争夺单个资源的情况，使用简单，但性能较低。
  • 事件 : 适用于等待特定事件发生后才能继续执行的场景，同步效率高。
  • 临界区: 适用于保护共享资源的场景，性能较高。
  • 信号量: 适用于控制同时访问资源的进程数量，但使用较复杂，容易产生死锁。
  • 命名管道: 适用于进程间的通信和同步，但性能较低。
  • 共享内存: 适用于共享大块数据的场景，需要进行同步操作，可能引发竞态条件。

根据具体的场景和需求，可以选择合适的进程同步机制来实现进程间的同步和通信。

键盘会跳舞
关注
  • 18
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
四种进程或线程同步互斥的控制方法介绍
02-21
很想整理一下自己对进程线程同步互斥的理解。正巧周六一个刚刚回到学校的同学请客吃饭。在吃饭的过程中，有两个同学，为了一个问题争论的面红耳赤。一个认为.Net下的进程线程控制模型更加合理。一个认为Java下的线程池策略比.Net的好。大家的话题一下转到了进程线程同步互斥的控制问题上。回到家，想了想就写了这个东东。现在流行的进程线程同步互斥的控制机制，其实是由最原始最基本的4种方法实现的。由这4种方法组合优化就有了.Net和Java下灵活多变的，编程简便的线程进程控制手段。这4种方法具体定义如下在《操作系统教程》ISBN7-5053-6193-7一书中可以找到更加详细的解释1、临界区:通过对多线程的
多任务操作系统进程和线程同步控制
01-09
在多任务操作系统环境下，进程和线程的同步控制是多线程和多进程编程的一个重点，稍作总结 　一、临界区（criticalsection) 　1、临界区是线程同步的一种方式，即它在同一时刻只允许一个线程进入，其他线程只能等...
Linux和windows进程同步与线程同步那些事儿（五）：Linux下进程同步
Mr.Sugarcane
01-10 934
linux进程同步讲解
Linux和windows进程同步与线程同步那些事儿（一）
Mr.Sugarcane
01-05 1026
windows与linux进程同步及线程同步方法归纳
Linux和windows进程同步与线程同步那些事儿（二）： windows线程同步详解示例
Mr.Sugarcane
01-09 1090
windows线程同步详解和代码示例
多进程同步方法解决生产者-消费者问题(linux线程实现)
05-15
设计要求:(1)每个生产者和消费者对有界缓冲区进行操作后,即时显示有界缓冲区的全部内容,当前指针位置和生产者/消费者线程的标识符.(2)生产者和消费者各有两个以上.(3)多个生产者或多个消费者之间须有共享对缓冲区...
操作系统——实验四 windows中线程的创建和同步控制
08-05
在windows的环境下，创建一个控制台进程，此进程创建两个并发线程，一个是读线程，另一个是写线程。这两个线程共享一个数组A,写线程对数组分别进行10次写操作，每次写操作对A的每个元素赋一个相同的值；读线程对数组...
windows下局域网内循环ping设备的脚本（ip地址从192.168.1.1~192.168.1.255）
热门推荐
Mr.Sugarcane
04-03 1万+
有时候会碰到这样的情况，一台设备可以联网，但是你无法获知其ip地址，该怎么办。下面通过脚本循环执行ping指令的方法可以帮你找到答案。 创建一个ping.bat的文件，在文件中写入以下命令： @Echo off date /t >> IPList.txt 　　time /t >> IPList.txt 　　echo =========== >&gt...
Windows10 PowerShell 使用 telnet 功能
Mr.Sugarcane
03-05 9590
有时候需要telnet远程客户端，电脑上没有安装第三方工具，不用着急。你可以这样做： 一、开启服务 在控制面版==》程序和功能==》启用或关闭windows功能 ==》勾选Telnent Client项目。确认后，系统自动加载组件。 2、在终端工具中使用telnet 我这里使用 PowerShell 连接远程客户端： telnet ip port telnet 的默认...
使用Windows PowerShell 连接远程服务器
Mr.Sugarcane
02-18 7220
1、使用管理员权限启动Windows PowerShell。 2、在控制台中使用SSH指令。 ssh usrname@ip 更多ssh用法参照如下： PS C:\WINDOWS\system32> ssh -help unknown option -- h usage: ssh [-46AaCfGgKkMNnqsTtVvXxYy] [-B bind_interface]...
Dos下如何判断某个文件或者字符串中包含某个子串
Mr.Sugarcane
01-14 3749
例子： 我们读取网卡信息，并判断是否存在虚拟ip地址为“10.8.0.6”的网卡，如果存在，则生成一个叫做status.txt的文件，并写入Ok字符串。在cmd下我们可以直接如下操作： ipconfig | find "10.8.0.6" /N >nul && echo "Ok" > status.txt 那么引申使用，在应用程序中判断是否存...
VS C++ 生成类图
Mr.Sugarcane
12-22 3698
C++中如何快速清晰的了解定义类型及类型之间的关联关系，一个好的类图有助于你快速了解。那么怎么去生成一个类图呢，下面步骤可以帮到你。
基于vspd DLL二次开发的虚拟串口工具
Mr.Sugarcane
09-18 3439
最近项目需要，早期使用com0com做虚拟串口工具的二次开发，但是发现在系统兼容性上存在很多的问题，后来改用vspd 的免费sdk做开发，在稳定性和兼容性上确实提升了很多。功能调用非常简单，可以参照如下的demo。库文件的话自行下载和链接。需要源码可以留言。 有一点需要提醒的是，使用该vspd的dll创建的虚拟串口对，在电脑重启之后将不会存在，其原因是创建的虚拟串口对没有写入到注册表中。具体操作请...
Windows CMD 常用指令
Mr.Sugarcane
12-18 2353
有关某个命令的详细信息，请键入 HELP 命令名 ASSOC 显示或修改文件扩展名关联。 ATTRIB 显示或更改文件属性。 BREAK 设置或清除扩展式 CTRL+C 检查。 BCDEDIT 设置启动数据库中的属性以控制启动加载。 CACLS 显示或修改文件的访问控制列表(ACL)。 CALL ...
windows下的另一个辅助工具Devcon.exe（用会了绝对是神器）
Mr.Sugarcane
12-30 1680
``` Device Console Help: devcon.exe [-r] [-m:\\<machine>] <command> [<arg>...] -r Reboots the system only when a restart or reboot is required. <machine> Speci...
Windows内存管理（一）：Windows性能监视器(PerfMon)
Mr.Sugarcane
01-09 1399
windows内存管理 性能监视器 perfmon
VS 远程开发调试环境搭建 简明教程
Mr.Sugarcane
04-10 1260
VS远程调试环境简明搭建教程
Windows内存管理（二）:内存架构 浅谈一二
Mr.Sugarcane
01-09 912
windows内存管理
windows进程同步
最新发布
03-26
Windows进程同步是指在多个进程之间协调和同步操作的一种机制。它确保多个进程能够按照特定的顺序执行，避免竞争条件和数据不一致的问题。Windows提供了多种进程同步的机制，包括： 1. 互斥量（Mutex）：互斥量是一种最常用的进程同步机制。它允许一个进程独占地访问共享资源，其他进程需要等待互斥量释放后才能访问。 2. 信号量（Semaphore）：信号量是一种计数器，用于控制对共享资源的访问。它可以允许多个进程同时访问共享资源，但限制同时访问的进程数量。 3. 事件（Event）：事件是一种用于通知和同步进程的机制。它可以用于线程间的通信和同步，通过设置和重置事件状态来实现进程的等待和唤醒。 4. 临界区（Critical Section）：临界区是一段代码，用于保护共享资源的访问。只有一个进程可以进入临界区执行代码，其他进程需要等待。 5. 读写锁（Reader- Lock）：读写锁是一种特殊的锁机制，用于控制对共享资源的读写操作。它允许多个进程同时读取共享资源，但只允许一个进程进行写操作。 以上是Windows进程同步的一些常用机制，它们可以根据具体的需求选择和使用。通过合理地使用这些机制，可以确保多个进程之间的协调和同步，提高系统的并发性和稳定性。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

键盘会跳舞

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值