java并发包下的并发工具类

1.Exchanger

功能：用于线程间数据的交换

应用场景：1）遗传算法，目前还不是特别理解  2）校对工作，假设A,B线程做同一件任务，可以通过数据校验判断两线程是否正确的工作

例子：是一个简单的校对工作例子

public class TestExchanger {
    public static void main(String[] args) {
        Exchanger<String> exchanger = new Exchanger<>();
        ExecutorService es = Executors.newFixedThreadPool(2);  //拥有两个线程的线程池
        es.execute(new Runnable() {
            @Override
            public void run() {
                String A = "银行流水A";
                try {
                    exchanger.exchange(A);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
 
        es.execute(new Runnable() {
            @Override
            public void run() {
                String B = "银行流水B";
                try {
                    String A = exchanger.exchange(B);
                    System.out.println("A和B数据是否一致： " + A.equals(B) + ",A: " + A + ",B: " + B);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
    }
}

Exchanger类中最重要的一个方法就是exchange()，该方法用于交换信息，并且接受来自另外一个线程的数据,exchange()方法里面还可以加参数。exchange(V x,long timeout,TimeUnit unit)设置一个最大等待时间避免一直等待

注意：信息交换是在同步点（Exchager提供一个同步点）进行交换，而不是两个线程调用了exchange()方法就进行交换。

底层实现：Lock+Condition，暂时还没深入，学习了进行补充

2.Semaphore

功能：控制同时访问特定资源的线程数量

应用场景：流量控制，比如数据库的连接

例子：

public class TestSemaphore {
    public static void main(String[] args) {
        // 线程池
        ExecutorService exec = Executors.newCachedThreadPool();
        //一次只能5个线程同时访问
        final Semaphore semp = new Semaphore(5);
        // 模拟20个客户端访问
        for (int index = 0; index < 20; index++) {
            final int NO = index;
            Runnable run = new Runnable() {
                public void run() {
                    try {
                        // 获取许可
                        semp.acquire();
                        System.out.println("Accessing: " + NO);
                        Thread.sleep((long) (Math.random() * 10000));
                        // 访问完后，释放
                        semp.release();
                        System.out.println("-----------------"+semp.availablePermits());
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
 
                }
 
            };
            exec.execute(run);
        }
 
        // 退出线程池
        exec.shutdown();
 
    }
}

同时有五个线程可以执行，获取资源后打印语句后随机睡眠，最后释放资源，semp.availablePermits()，可以获得的许可数量，释放一个后将有一个没有被分发的许可证，当有多的许可证时，会采取先到先得的方式分配许可

Semaphore有两个构造函数，Semaphore(int)和Semaphore(int，boolean)。参数中的int表示该信号量拥有的许可数量，boolean表示获取许可的时候是否是公平的，如果是公平的那么，当有多个线程要获取许可时，会按照线程来的先后顺序分配许可，否则，线程获得许可的顺序是不定的

3.CyclicBarrier

功能：控制同时访问特定资源的线程数量

应用场景：希望创建一组任务，并行执行，在进行下一个步骤之前等待，直到所有任务完成

例子：赛马比赛。只有当所有马一起到达栅栏时，才能继续跑下一个栅栏

Horse类：

public class Horse implements Runnable {
    private static int counter = 0;
    private final int id = counter++;
    private int strides = 0;
    private static Random rand = new Random(47);
    private static CyclicBarrier barrier;
    public Horse(CyclicBarrier b) { barrier = b; }
    public synchronized int getStrides() { return strides; }
    public void run() {
        try {
            while(!Thread.interrupted()) {
                synchronized(this) {
                    strides += rand.nextInt(3); // Produces 0, 1 or 2
                }
                barrier.await();  //在栅栏处等待
            }
        } catch(InterruptedException e) {
            // A legitimate way to exit
        } catch(BrokenBarrierException e) {
            // This one we want to know about
            throw new RuntimeException(e);
        }
    }
    public String toString() { return "Horse " + id + " "; }
    public String tracks() {
        StringBuilder s = new StringBuilder();
        for(int i = 0; i < getStrides(); i++)
            s.append("*");
        s.append(id);
        return s.toString();
    }
} 

HorseRace类：

public class HorseRace {
    static final int FINISH_LINE = 75;
    private List<Horse> horses = new ArrayList<Horse>();
    private ExecutorService exec =
            Executors.newCachedThreadPool();
    private CyclicBarrier barrier;
    public HorseRace(int nHorses, final int pause) {
        barrier = new CyclicBarrier(nHorses, new Runnable() {
            public void run() {
                System.out.println("执行runnable方法的线程: " + Thread.currentThread().getName());
                StringBuilder s = new StringBuilder();
                for(int i = 0; i < FINISH_LINE; i++)
                    s.append("="); // The fence on the racetrack
                System.out.println(s);
                for(Horse horse : horses)
                    System.out.println(horse.tracks());
                for(Horse horse : horses)
                    if(horse.getStrides() >= FINISH_LINE) {
                        System.out.println(horse + "won!");
                        exec.shutdownNow();
                        return;
                    }
                try {
                    TimeUnit.MILLISECONDS.sleep(pause);
                } catch(InterruptedException e) {
                    System.out.println("barrier-action sleep interrupted");
                }
            }
        });
 
        for(int i = 0; i < nHorses; i++) {
            Horse horse = new Horse(barrier);
            horses.add(horse);
            exec.execute(horse);
        }
    }
 
    public static void main(String[] args) {
        int nHorses = 7;
        int pause = 200;
 
        new HorseRace(nHorses, pause);
    }
}

CyclicBarrier有两个构造函数：

public CyclicBarrier(int parties, Runnable barrierAction) {}
public CyclicBarrier(int parties) {}

parties代表一次要并行执行的任务，barrierAction当这些线程都到达barries状态时要执行的任务，会选择一个线程去启动这个任务

重载方法await()

public int await() throws InterruptedException, BrokenBarrierException { }
public int await(long timeout, TimeUnit unit)throws InterruptedException,BrokenBarrierException,TimeoutException { }

第一个方法用来挂起当前线程，直至所有线程都到达barrier状态再同时执行后续任务。第二个方法是让这些线程等待至一定的时间，如果还有线程没有到达barrier状态就直接让到达barrier的线程执行后续任务

4.CountDownLatch

功能：允许一个或多个线程等待其他线程完成操作

应用场景：

例子：

public class TestCountDown {
    private static CountDownLatch c = new CountDownLatch(2);  //等待线程的执行数量为2
    public static void main(String[] args) throws InterruptedException {
        new Thread(
                new Runnable() {
                    @Override
                    public void run() {
                        System.out.println(1);
                        c.countDown();
                    }
                }
        ).start();
 
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println(2);
                c.countDown();
            }
        }).start();
 
        c.await();  //阻塞当前线程，即main线程等待其他线程完成任务以后才能执行
        System.out.println(3);
    }
 
}