本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：线程同步是多线程编程的核心概念之一，特别是在Windows平台下使用Visual C++开发时。本实例工程展示了如何通过信号量（Semaphore）来实现线程间的协调与同步，确保资源的有效管理并防止竞态条件。工程中包含了信号量的创建、线程的创建、资源的访问、线程的退出以及错误处理的关键部分，从而为开发者提供了学习和应用线程同步方法的实际案例。

1. 线程同步概念

在现代操作系统中，多线程编程是实现复杂任务并行处理的关键技术。线程同步机制是确保线程安全、避免数据竞争和条件竞争不可或缺的部分。随着多核处理器的发展，合理地利用线程同步机制，可以提升应用程序的性能和响应速度。本文将从线程同步的基础概念入手，逐步深入探讨信号量（Semaphore）的作用、创建和使用，以及如何正确处理线程退出和资源释放，最终总结在实际工程中如何有效进行错误处理和问题诊断。让我们开始进入线程同步的世界，揭开其背后的奥秘。

2. 信号量的定义及作用

信号量是操作系统提供的一种用于进程或线程间同步与互斥访问资源的机制。理解信号量的概念和作用是掌握更高级并发控制和资源管理技术的基础。

2.1 信号量的概念解析

2.1.1 信号量的定义

信号量是一个抽象的数据类型，通常被用来解决多个进程或线程访问共享资源时的同步问题。信号量的本质是一个非负的整数计数器，它被用来控制对共享资源的访问。这个计数器的值表示可用资源的数量，对信号量的操作包括等待（wait）和信号（signal）两种原子操作。

  • 等待（wait）操作 ：当一个线程（进程）对一个信号量执行等待操作时，系统会检查信号量的值是否大于0，如果是，则将其减1并继续执行。如果信号量的值为0，则线程会进入等待状态，直到信号量的值再次大于0。
  • 信号（signal）操作 ：当一个线程完成对共享资源的使用后，它会对信号量执行信号操作，将信号量的值加1。如果有其他线程因为等待这个信号量而进入阻塞状态，系统会唤醒其中一个线程继续执行。

2.1.2 信号量在同步中的作用

信号量在同步中的作用体现在它能够协调多个线程对共享资源的有序访问。举一个简单的例子，假设有一个线程池需要管理一组线程来完成任务，而这些任务需要访问同一个文件系统资源。为防止文件访问冲突，可以使用信号量来限制同时访问文件系统的线程数量。

信号量同步机制有以下特点：

  • 简单性 ：信号量的操作相对简单，易于理解和实现。
  • 灵活性 ：信号量可以实现多种同步模式，如互斥锁、计数信号量等。
  • 高效性 ：当信号量的值不为0时，等待操作几乎不涉及任何上下文切换，因此是高效的。

2.2 信号量与其他同步机制的比较

2.2.1 信号量与互斥锁的区别

互斥锁（Mutex）是另一种常用的同步机制。与信号量不同，互斥锁在同一时刻只允许一个线程访问共享资源。而信号量的计数器可以大于1，允许多个线程同时访问共享资源，这取决于信号量的初始值。

  • 互斥锁 ：适用于简单的互斥访问，可以防止竞态条件的发生。互斥锁的使用比信号量简单，因为它涉及到的操作只有锁定和解锁。
  • 信号量 ：适用于复杂的同步场景，可以实现资源计数，控制对资源的并发访问数量。

2.2.2 信号量与事件对象的区别

事件对象（Event）是一种同步机制，它用来通知线程某些事情已经发生。事件可以是有信号的（signaled）或无信号的（nonsignaled）。

  • 事件对象 ：当事件处于有信号状态时，等待该事件的线程可以继续执行。事件对象通常用于线程间通信，它没有资源计数的概念。
  • 信号量 ：信号量除了用于线程间通信，还可以用来限制对共享资源的并发访问。它有计数器来维护资源数量。

接下来，我们将详细探讨信号量的创建和使用方法，以及如何利用信号量来控制线程间对共享资源的并发访问。

3. 创建和使用信号量对象

在操作系统中，线程同步机制是一种重要的技术，它能够保证多个线程在竞争共享资源时不出现数据冲突。信号量是实现线程同步的一种手段。在本章中，我们将详细讨论创建和使用信号量对象的过程，包括如何通过API创建信号量，以及如何利用信号量来控制线程对共享资源的访问。

3.1 创建信号量对象方法（CreateSemaphore）

3.1.1 CreateSemaphore函数的参数解析

在Windows平台上，信号量是一种内核对象，可以用来同步多个进程中的线程对共享资源的访问。 CreateSemaphore 函数用于创建一个信号量对象，并返回该对象的句柄。该函数的原型如下：

HANDLE CreateSemaphore(
  LPSECURITY_ATTRIBUTES lpSemaphoreAttributes,
  LONG                 lInitialCount,
  LONG                 lMaximumCount,
  LPCTSTR              lpName
);
  • lpSemaphoreAttributes ：指向一个 SECURITY_ATTRIBUTES 结构体的指针，该结构体定义了返回的句柄是否可以被子进程继承。如果该参数为 NULL ，则句柄不能被继承。
  • lInitialCount ：设置信号量的初始计数值。初始值不能小于零，也不能大于 lMaximumCount 的值。
  • lMaximumCount ：定义了信号量的最大计数值。通常这个值被设置为1，这时信号量就变成了一个互斥锁。
  • lpName ：信号量对象的名称。如果此参数为 NULL ，表示创建一个匿名信号量。

3.1.2 创建信号量对象的示例代码

以下是一个使用 CreateSemaphore 创建信号量的示例代码：

#include <windows.h>
#include <stdio.h>

int main() {
    HANDLE hSemaphore;

    // 创建一个初始计数为1的信号量
    hSemaphore = CreateSemaphore(
        NULL,          // 默认安全属性
        1,             // 初始计数为1
        1,             // 最大计数为1
        NULL);         // 使用默认信号量名称

    if (hSemaphore == NULL) {
        // 创建信号量失败
        fprintf(stderr, "CreateSemaphore failed (%d)\n", GetLastError());
        return 1;
    }

    // 使用信号量的代码部分
    // ...

    // 释放信号量对象
    CloseHandle(hSemaphore);
    return 0;
}

在此代码中，我们创建了一个计数为1的信号量，意味着最多只允许一个线程访问受保护的资源。如果没有线程持有信号量，计数器的值为1；当一个线程获取了信号量，计数器的值减少到0，此时其他线程必须等待直到信号量被释放。

3.2 使用WaitForSingleObject等待信号量

3.2.1 WaitForSingleObject函数的使用场景

WaitForSingleObject 函数用于线程等待指定的同步对象的信号。这对于线程同步来说非常关键，因为当多个线程需要访问同一资源时，此函数可确保在资源可用时才进行访问。其函数原型如下：

DWORD WaitForSingleObject(
  HANDLE hHandle,
  DWORD  dwMilliseconds
);
  • hHandle ：要等待的同步对象的句柄。在本例中为创建的信号量对象的句柄。
  • dwMilliseconds ：线程等待的时间，以毫秒为单位。若设置为 INFINITE ，表示线程将无限期等待。

3.2.2 WaitForSingleObject的注意事项和错误处理

当 WaitForSingleObject 函数被调用时，线程将进入等待状态，直到以下几种情况发生：

  • 同步对象的状态变为信号状态。
  • 指定的超时时间已经到达。
  • 等待被同步对象的另一部分强制结束。

下面是一段示例代码：

DWORD dwWaitResult;

dwWaitResult = WaitForSingleObject(
    hSemaphore,        // 信号量句柄
    INFINITE);         // 无限等待直到信号量可用

if (dwWaitResult == WAIT_OBJECT_0) {
    // 成功获取信号量，访问共享资源
    // ...

    // 释放信号量
    ReleaseSemaphore(hSemaphore, 1, NULL);
} else {
    // 等待失败，处理错误情况
    fprintf(stderr, "WaitForSingleObject failed (%d)\n", GetLastError());
}

在这段代码中，如果线程成功获取了信号量，它将访问共享资源，并在完成后调用 ReleaseSemaphore 来释放信号量。如果 WaitForSingleObject 因为等待超时或信号量被其他线程持有而失败，线程将无法继续执行，此时应该处理错误情况。

在本章中，我们学习了创建和使用信号量对象的基本方法。首先通过 CreateSemaphore 创建信号量，并通过 WaitForSingleObject 等待信号量，从而实现对共享资源的线程同步。下一章中，我们将探讨线程并发访问共享资源时所面临的问题，以及如何使用信号量来解决这些问题。

4. 线程并发访问共享资源的控制

4.1 线程并发访问问题分析

4.1.1 共享资源的概念和问题

在多线程编程中，共享资源是指能够被多个线程访问和修改的数据或资源，它们通常是内存中的变量、文件、设备等。由于多线程环境下，各个线程的执行顺序和时长是不确定的，因此如果多个线程同时对同一资源进行读写操作，就可能产生冲突，导致数据不一致、程序出错、死锁等问题。

4.1.2 线程并发访问的常见问题

多线程并发访问共享资源时可能遇到的问题主要包括：

  • 竞态条件（Race Condition） ：当多个线程同时对共享资源进行读写时，资源的状态取决于线程的执行顺序和时长，结果难以预料。
  • 死锁（Deadlock） ：两个或多个线程在执行过程中，因争夺资源而造成的一种僵局。
  • 资源饥饿（Resource Starvation） ：某个线程因为其他线程占用资源，长时间无法执行。
  • 缓存一致性（Cache Inconsistency） ：在多核处理器上，每个核心可能有自己的缓存，如果缓存的数据没有同步，就会导致不一致性。

4.2 使用信号量控制并发访问

4.2.1 控制共享资源访问的策略

为了避免线程并发访问共享资源时出现问题，通常需要使用同步机制来控制访问。信号量是解决这类问题的一种有效方法。控制策略通常包括以下步骤：

  1. 初始化信号量为资源可用的数量。
  2. 在访问共享资源前，线程调用等待操作（WaitForSingleObject），以减少信号量的计数。
  3. 如果信号量的计数大于0，则允许线程访问资源；如果信号量的计数为0，则线程等待。
  4. 在访问完毕后，线程调用释放操作（ReleaseSemaphore），以增加信号量的计数。

4.2.2 实现线程同步的步骤和代码示例

实现步骤
  1. 创建信号量 ：使用CreateSemaphore函数创建一个信号量对象，并初始化其计数。
  2. 等待资源 ：在访问共享资源前，使用WaitForSingleObject函数等待信号量。
  3. 访问共享资源 ：当成功获得信号量后，对共享资源进行访问。
  4. 释放信号量 ：访问共享资源完成后，使用ReleaseSemaphore函数释放信号量。
代码示例

下面的代码展示了一个简单的使用信号量控制线程并发访问共享资源的示例。

#include <windows.h>
#include <stdio.h>

// 共享资源变量
int sharedResource = 0;
// 信号量对象
HANDLE semaphore;

// 线程函数
DWORD WINAPI ThreadProc(LPVOID lpParam) {
    DWORD threadId = GetCurrentThreadId();

    // 等待信号量
    WaitForSingleObject(semaphore, INFINITE);

    // 访问共享资源
    InterlockedExchangeAdd(&sharedResource, 1);

    // 模拟处理时间
    Sleep(1000);

    // 释放信号量
    ReleaseSemaphore(semaphore, 1, NULL);

    printf("Thread %d: Shared resource value is %d\n", threadId, sharedResource);
    return 0;
}

int main() {
    // 创建信号量，初始计数为3，最大计数也为3
    semaphore = CreateSemaphore(NULL, 3, 3, NULL);
    if (semaphore == NULL) {
        printf("Failed to create semaphore, error code: %d\n", GetLastError());
        return 1;
    }

    // 创建多个线程模拟并发访问
    HANDLE threads[5];
    for (int i = 0; i < 5; i++) {
        threads[i] = CreateThread(NULL, 0, ThreadProc, NULL, 0, NULL);
        if (threads[i] == NULL) {
            printf("Failed to create thread, error code: %d\n", GetLastError());
        }
    }

    // 等待所有线程结束
    WaitForMultipleObjects(5, threads, TRUE, INFINITE);

    // 关闭信号量和线程句柄
    CloseHandle(semaphore);
    for (int i = 0; i < 5; i++) {
        CloseHandle(threads[i]);
    }

    return 0;
}

在上述示例中，我们创建了一个信号量对象，将其初始计数设置为3，表示最多允许3个线程同时访问共享资源。每个线程在开始执行时，首先尝试等待信号量；当信号量计数大于0时，线程才能继续执行。访问完成后，线程调用ReleaseSemaphore函数增加信号量计数，允许其他等待的线程访问资源。通过信号量，我们可以有效地控制线程并发访问共享资源，确保数据的一致性和程序的正确性。

在这段代码中，我们使用了 InterlockedExchangeAdd 函数来保证对共享资源的原子性操作，避免了竞态条件。同时，通过信号量的计数来控制访问资源的线程数量，确保了线程间的同步，从而解决了多线程并发访问共享资源时可能遇到的问题。

5. 信号量的释放及线程退出处理

5.1 资源访问完成后的信号量释放（ReleaseSemaphore）

5.1.1 ReleaseSemaphore的基本原理

ReleaseSemaphore 函数是用于增加信号量计数的操作。当一个线程完成对共享资源的访问后，它需要通知系统该资源已经被释放，允许其他等待该资源的线程继续执行。信号量的值表示了可访问资源的数量。调用 ReleaseSemaphore 将会增加信号量的值，这样，等待该信号量的其他线程就可以继续执行，直到信号量的值再次减少到零。

5.1.2 ReleaseSemaphore的使用方法和示例

以下是使用 ReleaseSemaphore 的基本方法和示例代码：

#include <windows.h>

HANDLE hSemaphore; // 信号量句柄

void ReleaseResource()
{
    if (ReleaseSemaphore(hSemaphore, 1, NULL))
    {
        // 释放成功，信号量的值增加
        // 可以添加代码处理其他逻辑
    }
    else
    {
        // 释放失败，应处理错误情况
    }
}

在示例中， ReleaseSemaphore 的第一个参数是信号量对象的句柄，第二个参数是要增加的信号量的值（在此例中为1），第三个参数是一个可选的指向 LONG 的指针，用于接收信号量之前的值（通常为NULL）。

5.2 线程的创建与退出处理

5.2.1 线程的创建和生命周期管理

在 Windows 中，可以通过 CreateThread 函数创建新的线程。创建线程后，操作系统会为线程分配资源，将其加入到线程调度器，并开始执行指定的线程函数。线程的生命周期从创建开始，直到退出结束。

线程函数通常是一个无限循环，当不再需要执行该函数时，应当结束循环并调用 ExitThread 函数来退出线程。线程退出后，操作系统会回收其分配的资源。

5.2.2 线程退出前的资源清理和信号量正确释放

在退出线程之前，必须确保所有分配的资源被正确地清理。这包括释放线程在执行过程中获取的资源，例如锁、信号量等。如果线程持有信号量，则在退出之前应当释放，避免死锁或资源泄露。

示例代码如下：

#include <windows.h>

DWORD WINAPI ThreadFunction(LPVOID lpParam)
{
    // 线程执行的代码

    // 退出前释放信号量
    ReleaseSemaphore(hSemaphore, 1, NULL);

    // 清理其他资源
    // ...

    return 0;
}

// 在需要结束线程的地方
HANDLE hThread; // 线程句柄

// 假设线程函数中的资源已经释放完毕
// 然后等待线程结束
WaitForSingleObject(hThread, INFINITE);
CloseHandle(hThread); // 关闭线程句柄以释放资源

在代码中， ThreadFunction 是线程执行的函数。在线程执行完毕准备退出前，通过 ReleaseSemaphore 释放信号量。随后，在主线程中调用 WaitForSingleObject 等待子线程结束，并在子线程结束后关闭其句柄以释放资源。

本文还有配套的精品资源，点击获取 menu-r.4af5f7ec.gif

简介：线程同步是多线程编程的核心概念之一，特别是在Windows平台下使用Visual C++开发时。本实例工程展示了如何通过信号量（Semaphore）来实现线程间的协调与同步，确保资源的有效管理并防止竞态条件。工程中包含了信号量的创建、线程的创建、资源的访问、线程的退出以及错误处理的关键部分，从而为开发者提供了学习和应用线程同步方法的实际案例。


本文还有配套的精品资源，点击获取
menu-r.4af5f7ec.gif

Logo
AI Agent技术社区

Agent 垂直技术社区，欢迎活跃、内容共建。

更多推荐

cover

LangChain核心组件深入理解第四篇 -- Tool Agent运行的手和脚

avatar AI Agent技术社区
cover

AI智能体落地复盘：跨境业务提效多少？以及未来AI Agent的优化方向

avatar AI Agent技术社区

AI Agent 技术在汽车智驾平台中的应用与底层 Infra 技术栈全景

注：本文由AI辅助生成从“训练模型”转向“构建系统” —— 把大模型作为大脑，通过工程手段让其自主调用工具、记忆信息，稳定可靠地完成复杂任务。答案：不是全部部署，量产方案是“端云协同”——部分放车端，部分放云端。结论：对于底层智驾岗位，“车端部署 + 实时通信 + 智能路由”是核心护城河，Agent 搭建是基本功（默认必须会）。一句话总结：AI Agent 是“用模型”，AI Infra 是“供模

avatar AI Agent技术社区