package com.concurrent.test;

import java.util.concurrent.CountDownLatch;

import org.junit.Assert;

import org.junit.Test;

/**

 * 规定线程的执行顺序

 */

public class ThreadOrderTest {

    private long millisUnit = 1000;

    private int count = 2;

    class ThreadOrder {

        /*

         * join方法使多个线程依次执行

         */

        public long preserveOrderViaJoin() throws InterruptedException {

            long startMillis = System.currentTimeMillis();

            Thread tmp;

            for (int i = 0; i < count; i++) {

                tmp = new Thread(new Runnable() {

                    @Override

                    public void run() {

                        try {

                            Thread.sleep(millisUnit);

                        } catch (InterruptedException e) {

                            e.printStackTrace();

                        }

                    }

                }, "join-" + i);

                tmp.start();

                tmp.join();//不停地监测线程是否执行完成，执行完成才继续往下

            }

            return System.currentTimeMillis() - startMillis;

        }

        /*

         * CountdownLatch可同时阻塞多个线程，但它们可并发执行

         */

        public long preserveOrderViaCountdownLatch() throws InterruptedException {

            long startMillis = System.currentTimeMillis();

            final CountDownLatch countDownLatch = new CountDownLatch(count);

            for (int i = 0; i < count; i++) {

                new Thread(new Runnable() {

                    @Override

                    public void run() {

                        try {

                            Thread.sleep(millisUnit);

                        } catch (InterruptedException e) {

                            e.printStackTrace();

                        }

                        //只要计数器清零，等待的线程就可以开始执行，于是可以达到并发的效果

                        countDownLatch.countDown();

                    }

                },"countDownLatch-" + i).start();

            }

            countDownLatch.await();

            return System.currentTimeMillis() - startMillis;

        }

    }

    @Test

    public void testPreserveOrderViaJoin() throws InterruptedException {

        ThreadOrder threadOrder = new ThreadOrder();

        Assert.assertEquals(count, threadOrder.preserveOrderViaJoin() / millisUnit);

    }

    @Test

    public void testPreserveOrderViaCountdownLatch() throws InterruptedException {

        ThreadOrder threadOrder = new ThreadOrder();

        Assert.assertEquals(1, threadOrder.preserveOrderViaCountdownLatch() / millisUnit);

    }

}