信号量与线程安全，并发控制全解析

本篇文章主要是结合我之前面试的各种经历和实战开发中遇到的问题解决经验整理的，希望这篇《信号量与线程安全：并发控制详解》对你有很大帮助！欢迎收藏，分享给更多的需要的朋友学习~

信号量本身并非线程安全或非线程安全的概念，它是一种并发访问控制机制。当信号量的许可数量大于1时，允许多个线程同时访问共享资源。此时，资源的线程安全性至关重要，若资源本身不具备线程安全特性，则需额外同步措施以避免数据竞争，确保程序正确性。

在多线程编程中，我们经常需要控制对共享资源的访问。信号量（Semaphore）作为一种强大的同步原语，扮演着“门卫”的角色，它不直接声明资源是否线程安全，而是管理有多少个线程可以同时进入临界区，从而间接影响资源的并发访问模式。

信号量：并发访问的“门卫”

信号量本质上维护着一个许可计数器。当一个线程需要访问受保护的资源时，它会尝试获取一个许可（acquire()操作）。如果许可计数器大于零，线程成功获取许可，计数器减一，线程继续执行。如果许可计数器为零，线程将被阻塞，直到有其他线程释放许可（release()操作）为止。当线程完成对资源的访问后，它必须释放许可，计数器加一。

信号量的核心作用在于限制同时访问某个资源的线程数量。它不负责保护资源内部的数据一致性，而是提供了一种机制来控制并发级别。

二进制信号量（许可数 = 1）

当信号量的许可数被初始化为1时，它被称为二进制信号量。在这种配置下，信号量的行为与互斥锁（Mutex）非常相似。它确保在任何给定时刻，只有一个线程能够获取许可并访问受保护的资源。

在这种严格的串行访问模式下，即使被访问的共享资源本身不具备内部的线程安全机制（例如，一个普通的非同步集合或对象），通过二进制信号量的保护，实际上也实现了对该资源的线程安全访问，因为并发冲突被完全避免了。因此，对于只需要独占访问的场景，二进制信号量是一个有效的选择。

计数信号量（许可数 > 1）

当信号量的许可数大于1时，它被称为计数信号量。这意味着信号量允许指定数量的线程同时访问共享资源。例如，如果信号量初始化为3，则最多允许3个线程同时执行临界区代码。

在这种情况下，对资源线程安全性的考量变得至关重要：

1. 资源本身线程安全： 如果被访问的共享资源本身就是线程安全的（例如，Java中的ConcurrentHashMap，或者一个设计为不可变的对象，或者其内部已经通过synchronized关键字或ReentrantLock等机制做好了同步），那么计数信号量可以安全地用于控制并发访问。在这种情况下，信号量只是限制了同时访问的线程数量，而资源的内部同步机制确保了数据的一致性。

2. 资源本身非线程安全： 如果被访问的共享资源不是线程安全的（例如，一个普通的ArrayList或一个包含可变状态且未加锁的对象），那么即使通过计数信号量限制了同时访问的线程数量，仍然可能发生数据竞争（Race Condition）。当多个线程同时修改非线程安全资源时，可能会导致数据损坏、不一致或不可预测的行为。在这种情况下，仅仅使用计数信号量是不够的，你需要在资源内部或访问资源的关键代码段中，额外实现同步机制（如使用synchronized关键字、ReentrantLock、原子变量等）来保护非线程安全的部分。

同步与并发访问：概念辨析

理解信号量时，区分“同步”和“并发访问”的概念至关重要：

• 并发访问：指的是多个线程在时间上重叠地执行，可以同时访问共享资源。信号量就是用来管理这种并发访问的“数量”。
• 同步：指的是确保在并发访问下，数据的一致性和操作的正确性。这通常通过互斥锁、条件变量、原子操作等机制来实现，以避免数据竞争和死锁。

计数信号量允许并发访问，但它本身并不提供“同步”的功能来保证被访问资源的内部数据一致性。它只是限制了同时访问的线程数量。因此，当计数信号量允许并发访问时，资源的“同步”责任就落在了资源本身或开发者对资源访问的额外保护上。

示例代码

以下Java示例展示了计数信号量与非线程安全资源结合使用时可能出现的问题，以及如何通过同步来解决：

import java.util.concurrent.Semaphore;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

// 这是一个非线程安全的共享资源
class SharedResource {
    private int count = 0;

    public void increment() {
        // 模拟耗时操作，增加出现竞争的概率
        int temp = count;
        try {
            Thread.sleep(10); 
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        count = temp + 1;
        System.out.println(Thread.currentThread().getName() + " incremented count to: " + count);
    }

    public int getCount() {
        return count;
    }
}

public class SemaphoreConcurrencyExample {
    public static void main(String[] args) throws InterruptedException {
        final SharedResource resource = new SharedResource();
        // 允许2个线程同时访问
        final Semaphore semaphore = new Semaphore(2); 

        ExecutorService executor = Executors.newFixedThreadPool(5);

        System.out.println("--- 场景一：非线程安全资源与计数信号量 ---");
        for (int i = 0; i < 10; i++) {
            executor.submit(() -> {
                try {
                    semaphore.acquire(); // 获取许可
                    resource.increment(); // 访问非线程安全的共享资源
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    semaphore.release(); // 释放许可
                }
            });
        }

        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.SECONDS); // 等待任务完成
        System.out.println("最终计数 (非线程安全): " + resource.getCount()); 
        // 预期结果是10，但由于SharedResource非线程安全，实际结果可能小于10

        // 重置并演示如何通过同步解决
        System.out.println("\n--- 场景二：线程安全资源（通过同步）与计数信号量 ---");
        final SynchronizedSharedResource synchronizedResource = new SynchronizedSharedResource();
        final Semaphore synchronizedSemaphore = new Semaphore(2); // 仍然允许2个线程同时访问
        ExecutorService synchronizedExecutor = Executors.newFixedThreadPool(5);

        for (int i = 0; i < 10; i++) {
            synchronizedExecutor.submit(() -> {
                try {
                    synchronizedSemaphore.acquire();
                    synchronizedResource.increment(); // 访问线程安全的共享资源
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    synchronizedSemaphore.release();
                }
            });
        }

        synchronizedExecutor.shutdown();
        synchronizedExecutor.awaitTermination(1, TimeUnit.SECONDS);
        System.out.println("最终计数 (线程安全): " + synchronizedResource.getCount());
        // 预期结果是10，且通常能得到10
    }
}

// 这是一个线程安全的共享资源（通过 synchronized 关键字）
class SynchronizedSharedResource {
    private int count = 0;

    public synchronized void increment() { // 使用 synchronized 关键字保护
        int temp = count;
        try {
            Thread.sleep(10); 
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        count = temp + 1;
        System.out.println(Thread.currentThread().getName() + " incremented count to: " + count);
    }

    public synchronized int getCount() { // 读取操作也需要同步，以保证可见性
        return count;
    }
}

在上述SemaphoreConcurrencyExample中：

• 场景一展示了SharedResource是非线程安全的。即使我们使用许可数为2的信号量限制了并发访问，由于increment()方法内部没有同步机制，当两个线程同时执行temp = count;和count = temp + 1;时，仍然可能发生数据丢失，导致最终count的值小于10。
• 场景二中，SynchronizedSharedResource通过在increment()和getCount()方法上添加synchronized关键字，使其成为线程安全的。在这种情况下，即使信号量允许两个线程同时进入临界区，但由于increment()方法内部的synchronized锁，实际上同一时间只有一个线程能够修改count变量，从而保证了数据的一致性，最终count的值将是正确的10。

注意事项与总结

1. 信号量管理并发数量，不保证资源线程安全： 信号量控制的是同时访问某段代码或资源的线程数量。当许可数大于1时，它并不能自动使被访问的共享资源变得线程安全。
2. 资源本身的责任： 当使用计数信号量允许并发访问时，务必确保被访问的共享资源本身是线程安全的，或者在访问这些资源的临界区内部，已通过其他同步机制（如synchronized、Lock、原子变量等）妥善处理了数据竞争问题。
3. 二进制信号量与互斥锁： 许可数为1的信号量可以实现互斥锁的功能，确保独占访问。
4. 正确设计并发： 在设计并发系统时，需要综合考虑信号量的作用（限制并发数）和资源本身的线程安全特性（保证数据一致性），两者协同工作才能构建出健壮、高效且正确的并发应用。

总而言之，信号量是控制并发访问的有力工具，但它不是万能的。理解其工作原理和适用场景，并结合资源的线程安全特性进行设计，是编写高质量并发程序的关键。

好了，本文到此结束，带大家了解了《信号量与线程安全，并发控制全解析》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多文章知识！