Java信号量多许可场景解析

本篇文章给大家分享《Java信号量线程安全解析：许可数大于1场景》，覆盖了文章的常见基础知识，其实一个语言的全部知识点一篇文章是不可能说完的，但希望通过这些问题，让读者对自己的掌握程度有一定的认识(B 数)，从而弥补自己的不足，更好的掌握它。

本文深入探讨Java `Semaphore`在许可数大于1时的线程安全性问题。明确指出`Semaphore`本身并非使资源线程安全的机制，而是控制并发访问数量的工具。当许可数大于1时，多个线程可同时访问共享资源，因此资源本身的线程安全性设计至关重要，可能需要额外的同步机制来确保数据一致性。

信号量（Semaphore）概述

在并发编程中，信号量（Semaphore）是一种重要的同步工具，用于控制对共享资源的访问。它维护着一个许可集（permits），线程在访问资源前需要先获取许可（acquire()），访问完成后再释放许可（release()）。当没有可用许可时，尝试获取许可的线程将被阻塞，直到有其他线程释放许可。Semaphore的核心作用是限制同时访问某个特定资源的线程数量。

理解线程安全：资源而非信号量

在讨论Semaphore的线程安全性时，一个常见的误区是将其与它所保护的“资源”的线程安全性混淆。Semaphore本身作为一个并发工具类，其内部状态（如许可计数）是经过精心设计和实现的，以确保在多线程环境下的内部一致性，因此可以说Semaphore的内部操作是线程安全的。

然而，当谈论“线程安全”时，我们通常关注的是被Semaphore保护的共享资源。Semaphore的作用更像一个“门卫”，它决定了有多少人可以同时进入一个区域，但它并不能保证区域内部的所有设施（即共享资源）在使用时是安全的，这取决于设施本身的设计。

二元信号量（Permits = 1）

当Semaphore的许可数（permits）被初始化为1时，它实际上充当了一个二元信号量，其行为与互斥锁（Mutex）非常相似。在这种情况下：

• 在任何给定时刻，只允许一个线程成功获取许可并进入临界区访问共享资源。
• 由于排他性访问的特性，共享资源在被访问期间不会受到其他并发线程的干扰。
• 因此，在这种配置下，即使资源本身不是内部线程安全的，其在被Semaphore保护的临界区内也表现出线程安全的行为，因为并发修改被有效地排除了。

计数信号量（Permits > 1）

当Semaphore的许可数大于1时，情况变得更为复杂，这也是问题的核心所在。一个计数信号量允许指定数量（N）的线程同时获取许可并访问共享资源。

关键点： 此时，多个线程（最多N个）将同时在临界区内操作同一个共享资源。如果这个共享资源本身不是线程安全的（例如，一个普通的ArrayList、一个非同步的计数器），那么即使有Semaphore控制了并发线程的总数，这些同时访问的N个线程仍然可能导致数据竞争、不一致性或意外行为。Semaphore只是限制了“有多少人能同时进入房间”，但没有规定“进入房间的人如何安全地使用房间里的物品”。

考虑以下Java代码示例，它展示了一个计数信号量保护下的非线程安全共享资源：

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

public class CountingSemaphoreAndThreadSafety {

    // 这是一个非线程安全的共享资源
    private static int sharedCounter = 0;

    // 允许2个线程同时访问
    private static Semaphore semaphore = new Semaphore(2);

    public static void main(String[] args) throws InterruptedException {
        ExecutorService executor = Executors.newFixedThreadPool(5);

        Runnable task = () -> {
            try {
                semaphore.acquire(); // 获取许可
                String threadName = Thread.currentThread().getName();
                System.out.println(threadName + " acquired semaphore. Current Counter: " + sharedCounter);

                // 模拟对共享资源的非原子操作
                int temp = sharedCounter;
                Thread.sleep(50); // 模拟耗时操作，增加竞争的可能性
                sharedCounter = temp + 1; // 非原子性操作，可能导致数据丢失

                System.out.println(threadName + " released semaphore. New Counter: " + sharedCounter);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                System.out.println(Thread.currentThread().getName() + " was interrupted.");
            } finally {
                semaphore.release(); // 释放许可
            }
        };

        for (int i = 0; i < 10; i++) { // 启动10个任务
            executor.submit(task);
        }

        executor.shutdown();
        executor.awaitTermination(1, TimeUnit.MINUTES);

        System.out.println("Final sharedCounter value: " + sharedCounter);
        // 期望值是10，但由于竞争条件，实际值可能小于10
    }
}

在上述示例中，sharedCounter是一个普通的int类型，其增量操作sharedCounter = temp + 1;并非原子性的。当semaphore允许两个线程同时进入临界区时，这两个线程可能同时读取sharedCounter的旧值，然后各自基于旧值进行计算并写入，导致其中一个线程的更新丢失。尽管Semaphore控制了同时访问的线程数量，但它未能保证sharedCounter在并发访问下的正确性。

要解决这个问题，需要对sharedCounter的修改操作进行额外的同步，例如使用synchronized块、java.util.concurrent.atomic.AtomicInteger，或者更高级的Lock机制。

同步与并发访问的区别

• 并发访问（Simultaneous Access）： 指的是多个线程在时间上重叠地执行代码或访问资源。计数信号量正是通过控制许可数量来允许一定程度的并发访问。
• 同步（Synchronization）： 指的是协调多个线程的执行顺序和对共享数据的访问，以确保数据的一致性、完整性和避免竞争条件。synchronized关键字、Lock接口、原子类以及Semaphore本身都是Java中实现同步的机制。

计数信号量提供的是对并发访问数量的“门槛”控制，但它本身不直接提供数据一致性的“保证”。当多个线程被允许同时访问共享资源时，如果资源本身不是线程安全的，那么就需要额外的同步机制来确保这些并发访问是安全的，即保证数据一致性。

注意事项与总结

1. Semaphore是流量控制器，而非万能的线程安全保障： Semaphore的主要作用是限制对资源的并发访问数量，防止资源过载或死锁。它本身不赋予被保护资源线程安全的特性。
2. 关注共享资源的线程安全性： 在设计并发系统时，核心在于识别共享资源，并评估其在多线程环境下的线程安全性。
3. 组合使用同步机制：
   • 如果共享资源是天然线程安全的（例如，java.util.concurrent包中的集合类如ConcurrentHashMap，或者不可变对象），那么计数信号量可以高效地管理访问，无需额外的内部同步。
   • 如果共享资源不是线程安全的（如普通ArrayList、HashMap、非原子计数器），并且计数信号量允许大于1的并发访问，那么在acquire()和release()之间的临界区内部，仍可能需要使用synchronized块、Lock、Atomic类等更细粒度的同步机制来保护对该资源的修改操作。
4. 正确释放许可： 务必在finally块中调用release()，确保即使在发生异常时许可也能被释放，避免资源泄露和死锁。

综上所述，当Semaphore的许可数大于1时，它允许指定数量的线程并发访问共享资源。在这种情况下，共享资源本身的线程安全性变得至关重要。Semaphore控制的是“谁能进门”，而资源本身的线程安全设计（或在临界区内部增加额外的同步）则决定了“进门后如何安全地使用物品”。

今天带大家了解了的相关知识，希望对你有所帮助；关于文章的技术知识我们会一点点深入介绍，欢迎大家关注golang学习网公众号，一起学习编程~