【Semaphore】java并发编程之——Semaphore（包含你对Semaphore想要了解的一切）

        Semaphore（信号量）是一种用于控制多个线程并发访问共享资源的同步工具。它维护了一组许可（permits），线程在访问共享资源之前需要先获取许可，如果没有许可可用，则需要等待。

使用Semaphore的主要操作：

1、初始化：初始化一个Semaphore对象，并指定许可的数量。例如用Semaphore semaphore=new Semaphores（5）来创建一个初始许可数量为5 的Semaphore对象。

2、获取许可：线程通过acquire（）方法来获取许可。如果许可书大于0，则线程可以成功获取许可并继续进行。如果许可数为0，则线程进入等待状态，直到有许可可用。acquire（）方法许可成功时会减少许可数

3、释放许可：线程通过release（）方法来释放许可。释放后许可数会增加，其他等待的线程有机会获得许可

简单实例展示Semaphore如何控制通俗访问共享资源的线程数量

import java.util.concurrent.Semaphore;

public class SemaphoreExample {
    private static final int THREAD_COUNT = 10; // 线程数量
    private static final int MAX_CONCURRENT_COUNT = 5; // 最大并发数

    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(MAX_CONCURRENT_COUNT);

        for (int i = 0; i < THREAD_COUNT; i++) {
            Thread thread = new Thread(new Task(semaphore));
            thread.start();
        }
    }

    static class Task implements Runnable {
        private final Semaphore semaphore;

        public Task(Semaphore semaphore) {
            this.semaphore = semaphore;
        }

        @Override
        public void run() {
            try {
                semaphore.acquire(); // 获取许可
                System.out.println(Thread.currentThread().getName() + " 获取许可，开始执行任务");
                Thread.sleep(2000); // 模拟任务执行时间
                System.out.println(Thread.currentThread().getName() + " 任务执行完毕，释放许可");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                semaphore.release(); // 释放许可
            }
        }
    }
}

        在这个示例中，我们创建了一个包含5个许可的Semaphore对象。然后，创建了10个任务线程，并将Semaphore对象传递给每个任务。

        每个任务线程在运行时，首先尝试通过调用acquire（）方法获取许可。如果有可用的许可，线程将成功获取并继续执行任务。如果没有可用的许可，则线程将进入等待状态，直到有许可可用。

        任务线程模拟了一个耗时的任务（2秒），然后通过调用release（）方法释放许可。释放许可后，其他等待许可的线程将有机会获取许可并执行任务。

输出结果

可能的输出结果如下（顺序可能会有所不同）：

可能的输出结果如下（顺序可能会有所不同）：
Copy CodeThread-1 获取许可，开始执行任务
Thread-2 获取许可，开始执行任务
Thread-3 获取许可，开始执行任务
Thread-4 获取许可，开始执行任务
Thread-5 获取许可，开始执行任务
Thread-2 任务执行完毕，释放许可
Thread-1 任务执行完毕，释放许可
Thread-6 获取许可，开始执行任务
Thread-7 获取许可，开始执行任务
Thread-8 获取许可，开始执行任务
Thread-9 获取许可，开始执行任务
Thread-10 获取许可，开始执行任务
Thread-9 任务执行完毕，释放许可
Thread-6 任务执行完毕，释放许可
Thread-7 任务执行完毕，释放许可
Thread-8 任务执行完毕，释放许可
Thread-3 任务执行完毕，释放许可
Thread-4 任务执行完毕，释放许可
Thread-10 任务执行完毕，释放许可
Thread-5 任务执行完毕，释放许可

这里它都允许五个线程进行共享资源的访问了，那假如同时对一个变量修改，是不是Semaphore也不是线程安全的？

Semaphore本身并不提供线程安全性。它只用于控制并发访问共享资源的线程数量。

        如果多个线程同时对一个变量进行修改，在没有其他同步机制的情况下，Semaphore并不能保证线程安全性。Semaphore仅仅起到了限制并发访问的作用，但并未处理多线程之间的数据一致性问题。

        要实现线程安全性，可以结合使用Semaphore和其他适当的同步机制，如锁（Lock）或互斥量（Mutex）。这样可以保证在访问共享资源时，只允许一个线程进行操作，从而避免竞态条件和数据不一致的问题。

例如，在Java中，可以使用synchronized关键字或ReentrantLock来保证对共享资源的安全访问。你可以在使用Semaphore控制并发访问的同时，使用这些同步机制来确保线程安全性。

下面是一个示例，展示了如何结合Semaphore和synchronized来实现线程安全的访问：

import java.util.concurrent.Semaphore;

public class SharedResourceExample {
    private static final int THREAD_COUNT = 10; // 线程数量
    private static final int MAX_CONCURRENT_COUNT = 5; // 最大并发数

    private static int sharedVariable = 0; // 共享变量
    private static Semaphore semaphore = new Semaphore(MAX_CONCURRENT_COUNT);

    public static void main(String[] args) {
        for (int i = 0; i < THREAD_COUNT; i++) {
            Thread thread = new Thread(new Task());
            thread.start();
        }
    }

    static class Task implements Runnable {
        @Override
        public void run() {
            try {
                semaphore.acquire(); // 获取许可

                synchronized (SharedResourceExample.class) {
                    System.out.println(Thread.currentThread().getName() + " 获取许可，开始修改共享变量");
                    sharedVariable++; // 修改共享变量
                    System.out.println(Thread.currentThread().getName() + " 共享变量的值为：" + sharedVariable);
                }

                semaphore.release(); // 释放许可
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

        这个示例中使用了Semaphore来限制对共享资源（sharedVariable）的并发访问数量。而对于对共享变量的修改操作，则使用了synchronized关键字实现了线程安全性。

        每个任务线程在获取到Semaphore的许可后，进入synchronized块内部对共享变量进行修改。通过synchronized关键字的加锁机制，确保同一时间只有一个线程可以访问和修改共享变量，从而避免了竞态条件和数据不一致的问题。