以下示例均來自jdk concurrent包。
/**
 * 有一個任務，它要等待其他幾個任務
 * 執行完畢 之後才能執行
 *
 *
 * 倒計時器
 */
public class CountDownLatchTest {



    public static void main(String[] args){
        final CountDownLatch count = new CountDownLatch(2);
        new Thread(){
            public void run(){
                try {
                    TimeUnit.MILLISECONDS.sleep(1000);
                    System.out.println("線程"+Thread.currentThread().getName()+"正在執行...");
                    TimeUnit.MILLISECONDS.sleep(1000);
                    System.out.println("線程"+Thread.currentThread().getName()+"執行完畢 ");
                    count.countDown();

                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };
        }.start();



        //任務2
        new Thread(){
            public void run(){
                try {
                    TimeUnit.MILLISECONDS.sleep(1000);
                    System.out.println("線程"+Thread.currentThread().getName()+"正在執行...");
                    TimeUnit.MILLISECONDS.sleep(1000);
                    System.out.println("線程"+Thread.currentThread().getName()+"執行完畢 ");
                    count.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };
        }.start();

        try {
            count.await();
            System.out.println("主線程"+Thread.currentThread().getName()+"執行完畢 ");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

    }
}

 

/**
 *   周末部門聚餐
 *  所有人到齊了 之後 才能開始。。。
 *
 *
 * 可循環的同步屏障 */
public class CyclicBarrierTest {


    public static void main(String[] args){
        final CyclicBarrier barrier = new CyclicBarrier(20);
        ExecutorService threadPool = Executors.newCachedThreadPool();
        //模擬20個用戶
        for(int i=1;i<=20;i++){
            final int t=i;
            Runnable r = new Runnable(){
                public void run(){
                    //模擬每個人來的時間
                    try {
                        TimeUnit.MILLISECONDS.sleep(1000);
                        System.out.println(t+" 用戶到達"+(barrier.getNumberWaiting()+1)+"人到達");
                        barrier.await();
                        if(t==1){  //控制打印一條
                            System.out.println("人員全部到齊，開始吃飯");
                        }
                        Thread.sleep(300);
                        System.out.println(t+"用戶吃完，可以回家 了");
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                }
            };
            threadPool.execute(r);
        }

        threadPool.shutdown();
    }
}

 

/**
 * 團夥a 綁了B，放言要100萬， 與家屬c達到 一致意見在某個地方
 * 交換人質，於是A和c同時來到交換地點，同時一手交錢一手交貨
 * 使用exchanger實現
 */
public class ExchangerTest {

    public static void main(String[] args){
        ExecutorService threadPool = Executors.newCachedThreadPool();
        Exchanger<String> exchanger = new Exchanger<String>();

        threadPool.execute(new Runnable() {
            @Override
            public void run() {
                String data ="人質B";
                try {
                    String response = exchanger.exchange(data);
                    System.out.println("綁架者用B換回"+response);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        //家屬c
        threadPool.execute(new Runnable() {
            @Override
            public void run() {
                String data ="1000萬";
                try {
                    String response = exchanger.exchange(data);
                    System.out.println("C用1000萬換回"+response);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });

        threadPool.shutdown();
    }
}

 

/**
 * 信號量控制並發
 * 20個人  2個窗口買票
 *
 */
public class SemaphoreTest {
    private void execute(){
        Semaphore semaphore = new Semaphore(2);
        //線程池
        ExecutorService threadPool = Executors.newCachedThreadPool();
        //模擬20個線程
        for(int i=0;i<20;i++) {
            threadPool.execute(new MyTask(semaphore,i));
        }
    }

    class MyTask implements Runnable{
        private Semaphore semaphore; //信號 量 2個許可
        private int userNo;
        public MyTask(Semaphore semaphore,int userNo){
            this.semaphore=semaphore;
            this.userNo =userNo;
        }
        public void run(){
            //執行買票

            try {
                //獲取信號量許可，如果獲取不到 在此阻塞
                semaphore.acquire();

                //如果 獲取到， 可以往下執行 也就是買票
                System.out.println("用戶"+userNo+" 進入窗口，準備買票");
                TimeUnit.MILLISECONDS.sleep(1000);

                System.out.println("用戶"+userNo+" 買票完成，準備離開 ");
                TimeUnit.MILLISECONDS.sleep(1000);
                System.out.println("用戶"+userNo+" 買票完成，離開窗口 ");
                semaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    public static void main(String[] args){
        SemaphoreTest test = new SemaphoreTest();
        test.execute();

    }
}

多線程 實際場景應用篇