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等用法

最新文章

热门文章