Exchanger 和 Semaphore

java多线程工具类

从JDK 1.5开始，增加了java.util.concurrent包，它的引入大大简化了多线程的开发。

Exchanger

Exchanger（交换机）可以实现两个线程在运行中，实现交换对象的效果，例如 A 线程和 B线程，在运行中，交换了信息，然后继续运行。先到达的线程会阻塞等待后来的线程，直到两个线程都到达交换机后，互换对象，再各自执行。

感觉有点像谍战片，两个特务在互换情报的感觉…

public class Exchange_Demo {
    public static void main(String[] args) {
        Exchanger<String> exchanger= new Exchanger<>();
        String telegram1 = UUID.randomUUID().toString();
        String telegram2 = UUID.randomUUID().toString();
        new Thread(new Spy(exchanger,telegram1),"老鬼").start();
        new Thread(new Spy(exchanger,telegram2),"老枪").start();
    }
}
class Spy implements Runnable{
    Exchanger<String> exchanger ;
    String intelligence ;
    Spy(Exchanger<String> exchanger , String intelligence){
        this.exchanger = exchanger;
        this.intelligence = intelligence;
    }
    @Override
    public void run() {
        try {
            String name = Thread.currentThread().getName();
            System.out.println(name + "获得情报 : " + intelligence);
            System.out.println(name + "  ----->正在传递情报的路上");
            Thread.sleep(new Random().nextInt(10)*1000);
            System.out.println(name + " 已经到达，等待对方交换情报");
            String exchange = exchanger.exchange(intelligence);
            System.out.println(name + "情报交换，获得情报" + exchange);
            System.out.println(name + "继续自己的工作......");
            //dosomething
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

创建两条线程，实现对象交换

---

Semaphore

Semaphore（信号量) ，可以限制同时只有N条线程进入某一段代码，或者限制只有N条线程同时执行。主要通过抢夺信号量来获得执行权，执行完之后交换信号量。一般用在保护某一段重要代码只能有几条线程执行，或者流量控制。

一个抢夺信号量的例子

public class Semaphore_demo {
    public static void main(String[] args) {
        System.out.println("某某生病了... 10条线程去探望他..可是一次只能有3条线程去探望他");
        Semaphore semaphore = new Semaphore(3);
        for (int i = 0; i < 10; i++) {
            new Thread(new Viewer(semaphore)).start();
        }
    }
}

class Viewer implements Runnable {

    Semaphore semaphore;

    Viewer(Semaphore semaphore) {
        this.semaphore = semaphore;
    }

    @Override
    public void run() {
        try {
            String name = Thread.currentThread().getName();
            semaphore.acquire(1); //获取一个信号量
            System.out.println(name + "  已获得探望资格 正在进行探望");
            Thread.sleep(new Random().nextInt(10) * 1000);
            System.out.println(name + "  探望结束 归还资格");
            semaphore.release(1); // 归还
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Semaphore 在初始化的时候，还可以通过boolean值来配置是否公平策略，默认是不公平的。抢夺信号量的时候也可以指定抢多个少信号量。