Semaphore与资源线程安全：深度解析计数信号量

// Java 示例
Semaphore binarySemaphore = new Semaphore(1); // 二进制信号量

public void printDocument() {
    try {
        binarySemaphore.acquire(); // 获取许可
        // 只有获得许可的线程能执行到这里
        System.out.println(Thread.currentThread().getName() + " is printing...");
        // 模拟打印耗时操作
        Thread.sleep(1000);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    } finally {
        binarySemaphore.release(); // 释放许可
        System.out.println(Thread.currentThread().getName() + " finished printing.");
    }
}

// 概念性示例：共享的非线程安全计数器
class UnsafeCounter {
    private int count = 0;

    public void increment() {
        count++; // 这是一个非原子操作，可能导致竞态条件
    }

    public int getCount() {
        return count;
    }
}

// 使用计数信号量保护UnsafeCounter
Semaphore countingSemaphore = new Semaphore(2); // 允许2个线程同时访问
UnsafeCounter sharedCounter = new UnsafeCounter();

public void performConcurrentIncrement() {
    try {
        countingSemaphore.acquire(); // 获取许可
        // 两个线程可能同时执行到这里
        sharedCounter.increment(); // 此时可能发生竞态条件
        System.out.println(Thread.currentThread().getName() + " incremented counter to: " + sharedCounter.getCount());
        Thread.sleep(100); // 模拟其他操作
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    } finally {
        countingSemaphore.release(); // 释放许可
    }
}

// 线程安全的计数器
import java.util.concurrent.atomic.AtomicInteger;

class SafeCounter {
    private AtomicInteger count = new AtomicInteger(0);

    public void increment() {
        count.incrementAndGet(); // 原子性递增
    }

    public int getCount() {
        return count.get();
    }
}

// 使用计数信号量保护SafeCounter
Semaphore countingSemaphore = new Semaphore(2);
SafeCounter sharedSafeCounter = new SafeCounter();

public void performConcurrentSafeIncrement() {
    try {
        countingSemaphore.acquire();
        sharedSafeCounter.increment(); // 线程安全操作
        System.out.println(Thread.currentThread().getName() + " incremented counter to: " + sharedSafeCounter.getCount());
        Thread.sleep(100);
    } catch (InterruptedException e) {
        Thread.currentThread().interrupt();
    } finally {
        countingSemaphore.release();
    }
}