信号量与线程安全：深入理解并发访问控制

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;
    }
}