Semaphore与Exchanger的区别（semaphore和signal）

Semaphore 和 Exchanger 是 Java 并发编程中两个常用的同步工具类，它们都可以用于协调多个线程之间的执行顺序和状态，但它们的作用和使用方式有所不同：

Semaphore 类表示一个信号量，它可以用于限制同时访问某个共享资源的线程数量(即限制某段代码块的并发数)。Semaphore 初始化时需要指定一个许可数，每个线程执行前需要先获取一个许可，如果所有许可都被占用，则后续线程需要等待其他线程释放许可才能执行。Semaphore 可以用于控制并发线程的数量，或者限制某些操作的并发执行次数。

Exchanger 类表示一个交换器，它可以用于两个线程之间的数据交换。Exchanger 初始化时不需要指定任何参数，它提供了一个 exchange() 方法，当两个线程都调用了这个方法时，它们会交换数据并返回对方线程传递的数据。Exchanger 可以用于实现两个线程之间的数据交换，例如用于生产者-消费者模式中的数据传递。

因此，Semaphore 和 Exchanger 的主要区别在于：Semaphore 可以用于限制并发线程的数量或者限制某些操作的并发执行次数，而 Exchanger 只能用于两个线程之间的数据交换。此外，Semaphore 需要指定许可数，而 Exchanger 不需要。

// Semaphore 示例
import java.util.concurrent.Semaphore;

public class SemaphoreExample {

    public static void main(String[] args) throws InterruptedException {
      //如果 count=1，相当于变成了一个 synchronized 了（synchronized 和 ReentrantLock 都是一次只允许一个线程访问某个资源，
      //Semaphore(信号量)可以指定多个线程同时访问某个资源。）
        int count = 3;
        Semaphore semaphore = new Semaphore(count);
        
        for (int i = 0; i < count * 2; i++) {
            new Thread(() -> {
                try {
                    // 获取许可
                    semaphore.acquire();
                    // 模拟线程执行任务
                    System.out.println(Thread.currentThread().getName() + " 执行任务");
                    // 释放许可
                    semaphore.release();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }
    }
}

// Exchanger 示例
import java.util.concurrent.Exchanger;

public class ExchangerExample {

    public static void main(String[] args) throws InterruptedException {
        Exchanger<String> exchanger = new Exchanger<>();
        
        new Thread(() -> {
            String data = "Hello";
            try {
                // 交换数据并返回对方线程传递的数据
                String result = exchanger.exchange(data);
                System.out.println(Thread.currentThread().getName() + " 收到数据：" + result);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
        
        new Thread(() -> {
            String data = "World";
            try {
                // 交换数据并返回对方线程传递的数据
                String result = exchanger.exchange(data);
                System.out.println(Thread.currentThread().getName() + " 收到数据：" + result);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }).start();
    }
}

以上代码示例中，Semaphore 用于限制并发线程的数量，Exchanger 用于两个线程之间的数据交换。