Callable+countDownLatch+CyclicBarrier+Semaphore

区别：

1．可以有返回值
2．可以抛出异常
3．方法不同，run()/call()

public class TestCallable {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //new Thread(new Runnable()).start();
        //new Thread(new FutureTask<V>()).start();
        //new Thread(new FutureTask<V>(Callable)).start();
        MyThread thread = new MyThread();
        FutureTask task = new FutureTask(thread);//适配类

        new Thread(task,"A").start();
        new Thread(task,"B").start();//结果会被缓存，效率高 所以只输出一次call方法
        //这个get方法可能会产生阻塞！把他放到最后；或者用异步通信来处理
        Integer o =(Integer) task.get();
        System.out.println(o);
    }
}

class MyThread implements Callable<Integer> {
    @Override
    public Integer call() throws Exception {
        System.out.println("call方法");
        return 1024;
    }
}

·常用辅助类

1.countDownLatch

（1）countdown   数量减一

（2）await   等待计数器归零，然后再执行以下操作

每次有线程调用countDown（）方法，数量减一，直到计数器为0；countDownLatch被唤醒，继续执行。

public class TestCountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        //总数是7 ，必须要执行完任务的时候再继续往下走
        CountDownLatch countDownLatch = new CountDownLatch(7);
        for (int i = 0; i < 7; i++) {
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+" Go out!!!");
                countDownLatch.countDown();//数量-1
            },String.valueOf(i)).start();
        }
        countDownLatch.await();//等待计数器归0，然后再向下执行
        System.out.println("close door");
    }
}

2.CyclicBarrier（加法计数器）

public class TestCyclicBarrierDemo {
    public static void main(String[] args){
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,()->{
            System.out.println("集齐成功，召唤神龙");
        });

        for (int i = 0; i < 7; i++) {
            final int temp = i;//定义一个临时变量，lambda里面可以访问
            new Thread(()->{
                System.out.println(Thread.currentThread().getName()+"收集"+temp+"龙珠");
                try {
                    cyclicBarrier.await();//等待
                } catch (Exception e) {
                    e.printStackTrace();
                }
            },String.valueOf(i)).start();
        }
    }
}

3.Semaphore（信号量）

原理：

(1).semaphore.acquire()://获得，假如已经满了，等待，等到释放为止

(2).semaphore.release()://释放，会将当前的信号量释放+1，然后召唤等待的线程

作用：多个共享资源互斥的使用！并发限流，控制最大的线程数

public class TestSemaphore {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(2);
        for (int i = 0; i < 4; i++) {
            new Thread(()->{
                try {
                    semaphore.acquire();//获得
                    System.out.println(Thread.currentThread().getName()+"抢到了车位");
                    TimeUnit.SECONDS.sleep(1);
                    System.out.println(Thread.currentThread().getName()+"离开了车位");
                } catch (Exception e) {
                    e.printStackTrace();
                }finally {
                    semaphore.release();//释放
                }
            }).start();
        }
    }
}