JAVA concurrent包下Semaphore、CountDownLatch等用法

CountDownLatch 跟join的区别

CountDownLatch用处跟join很像，但是CountDownLatch更加灵活，如果子线程有多个阶段a、b、c; 那么我们可以实现在a阶段完成后（在a阶段后，b、c阶段之前， latch.countDown();），就可以往下运行，主线程并不用等子线程把b、c阶段都跑完。
latch.countDown() 其实是state -1 操作，latch.await() 其实一直在判断state == 0 如果为0就不再等待向下执行，基于AQS实现。
以下代码展示的是跟join（）用处相同。

import java.util.concurrent.CountDownLatch;

public class CountDownLatchTest {
    public static void main(String[] args) {
        final CountDownLatch latch = new CountDownLatch(2);

        new Thread() {
            @Override
            public void run() {
                try {
                    System.out.println(Thread.currentThread().getName() + "sleep 3s");
                    Thread.sleep(3000);
                    latch.countDown();

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

            }
        }.start();


        new Thread() {
            @Override
            public void run() {
                try {
                    System.out.println(Thread.currentThread().getName() + "sleep 3s");
                    Thread.sleep(3000);
                    latch.countDown();

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


        System.out.println(Thread.currentThread().getName() + "我是main线程");
        try {
            latch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println("main线程结束了。。。");

    }
}

CountDownLatchTest result

main我是main线程
Thread-1sleep 3s
Thread-0sleep 3s
main线程结束了。。。

感觉Semaphore类，可以做限流，像令牌token一样

import java.util.concurrent.Semaphore;

public class SemaphoreTest {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(5);
        for (int i = 0; i < 8; i++) {
            new Work(i,semaphore).start();
        }
    }


    static class Work extends Thread {

        int num;
        Semaphore sem;

        public Work(int num, Semaphore sem) {
            this.num = num;
            this.sem = sem;
        }

        @Override
        public void run() {
            try {
                sem.acquire();
                System.out.println(Thread.currentThread().getName() +" worker.NO."+ String.valueOf(num)+" 占用了机器，开始生产。。。");
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() +" worker.NO."+ String.valueOf(num)+" 释放了机器。");
            sem.release();
        }
    }

Semaphore result

Thread-0 worker.NO.0 占用了机器，开始生产。。。
Thread-1 worker.NO.1 占用了机器，开始生产。。。
Thread-2 worker.NO.2 占用了机器，开始生产。。。
Thread-3 worker.NO.3 占用了机器，开始生产。。。
Thread-4 worker.NO.4 占用了机器，开始生产。。。
Thread-0 worker.NO.0 释放了机器。
Thread-5 worker.NO.5 占用了机器，开始生产。。。
Thread-1 worker.NO.1 释放了机器。
Thread-6 worker.NO.6 占用了机器，开始生产。。。
Thread-2 worker.NO.2 释放了机器。
Thread-7 worker.NO.7 占用了机器，开始生产。。。
Thread-3 worker.NO.3 释放了机器。
Thread-4 worker.NO.4 释放了机器。
Thread-5 worker.NO.5 释放了机器。
Thread-7 worker.NO.7 释放了机器。
Thread-6 worker.NO.6 释放了机器。

JAVA concurrent包下Semaphore、CountDownLatch等用法

推荐阅读更多精彩内容