@Data

public abstract class BaseLatch {

    private int limit;

    protected int running;

    BaseLatch(int limit) {

        this.limit = limit;

        running = limit;

    }

    public abstract void await() throws InterruptedException;

    public abstract void await(long ms) throws InterruptedException, TimeoutException;

    public abstract void countDown();

}

class CountDownLatch extends BaseLatch {

    public CountDownLatch(int limit) {

        super(limit);

    }

    @Override

    public void await() throws InterruptedException {

        synchronized (this) {

            while (this.running > 0) {

                this.wait();

            }

        }

    }

    @Override

    public void await(long ms) throws InterruptedException, TimeoutException {

        Assert.isTrue(ms > 0, "不允许小于0");

        final long endTime = System.currentTimeMillis() + ms;

        synchronized (this) {

            while (this.running > 0) {

                long balanceTime = endTime - System.currentTimeMillis();

                if (balanceTime <= 0) {

                    throw new TimeoutException();

                }

                this.wait(balanceTime);

            }

        }

    }

    @Override

    public void countDown() {

        synchronized (this) {

            if (this.running <= 0) {

                throw new IllegalStateException("");

            }

            this.running--;

            this.notifyAll();

        }

    }

}

class LatchTest {

    public static void main(String[] args) throws InterruptedException {

        StopWatch stopWatch = new StopWatch();

        stopWatch.start();

        Work<Integer>[] works = new Work[2];

        BaseLatch latch = new CountDownLatch(works.length);

        for (int i = 0; i < works.length; i++) {

            works[i] = new Work<Integer>(latch);

            new Thread(works[i]).start();

        }

        try {

            latch.await(5000);

        } catch (TimeoutException ex) {

        }

        for (int i = 0; i < works.length; i++) {

            System.out.println(works[i].getResult());

        }

        stopWatch.stop();

        System.out.println("共消耗时间:" + stopWatch.getTotalTimeSeconds() + "秒");

    }

}

class Work<T> extends Thread {

    private BaseLatch latch;

    private T result;

    public Work(BaseLatch latch) {

        this.latch = latch;

    }

    @Override

    public void run() {

        try {

            Random random = new Random();

            int ms = random.nextInt(10) + 1;

            Thread.sleep(1000 * ms);

            this.result = (T) (Object) ms;

        } catch (InterruptedException e) {

            e.printStackTrace();

        } finally {

            latch.countDown();

        }

    }

    public T getResult() {

        return result;

    }

}

null

2

共消耗时间:5.012秒