Java多线程之JUC辅助类

1. JUC辅助类

1.1 CountDownLatch

  • 减少计数
  • 方法
    • await() / await(long timeout, TimeUnit unit) (unit 时间单位)
      • 阻塞,直到count为0,或线程被中断,或达到给定的时间
    • countDown()
      • 计数减一,直到为0,释放等待线程
  • 当一个或多个线程调用await方法时,这些线程会阻塞,其它线程调用countDown方法会将计数器减1(调用countDown方法的线程不会阻塞),当计数器的值变为0时,因await方法阻塞的线程会被唤醒,继续执行。
public class CountDownLatchDemo {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch count = new CountDownLatch(6);
        for (int i = 0; i < 6; i++) {
            new Thread(() -> {
                System.out.println(Thread.currentThread().getName()+"\t 离开");
                count.countDown();
            }, String.valueOf(i)).start();
        }
        count.await();//阻塞,直到count=0,main线程才继续向下执行
        System.out.println("全部离开");
    }
}

1.2 CyclicBarrier

  • 可循环(Cyclic)使用的屏障(Barrier)。它要做的事情是,让一组线程到达一个屏障(也可以叫同步点)时被阻塞,直到最后一个线程到达屏障时,屏障才会开门,所有被屏障拦截的线程才会继续干活。线程进入屏障通过CyclicBarrier的await()方法
public class CyclicBarrierDemo {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(7,() -> {
            System.out.println("召唤神龙");
        });

        for (int i = 1; i <= 7; i++) {
            new Thread(() -> {
                System.out.println("获得第"+Thread.currentThread().getName()+"颗龙珠!");
                try {
                    cyclicBarrier.await();
                } catch (Exception e) {
                    e.printStackTrace();
                }
                System.out.println("线程"+Thread.currentThread().getName()+"====>"+
                        Thread.currentThread().getState());
            }, String.valueOf(i)).start();
        }

    }
}
/*
获得第1颗龙珠!
获得第4颗龙珠!
获得第5颗龙珠!
获得第3颗龙珠!
获得第2颗龙珠!
获得第6颗龙珠!
获得第7颗龙珠!
召唤神龙
线程5====>RUNNABLE
线程3====>RUNNABLE
线程2====>RUNNABLE
线程1====>RUNNABLE
线程6====>RUNNABLE
线程4====>RUNNABLE
线程7====>RUNNABLE
*/

1.3 Semaphore

  • 在信号量上我们定义两种操作:
    • acquire(获取) 当一个线程调用acquire操作时,它要么通过成功获取信号量(信号量减1),要么一直等下去,直到有线程释放信号量,或超时。
    • release(释放)实际上会将信号量的值加1,然后唤醒等待的线程。
  • 信号量主要用于两个目的,一个是用于多个共享资源的互斥使用,另一个用于并发线程数的控制。
public class SemaphoreDemo {
    public static void main(String[] args) {
        Semaphore semaphore = new Semaphore(3);
        for (int i = 1; i <= 6; i++) {
            new Thread(() -> {
                try {
                    semaphore.acquire();
                    System.out.println(Thread.currentThread().getName() + "\t抢到车位!");
                    TimeUnit.SECONDS.sleep(new Random().nextInt(5));
                    System.out.println(Thread.currentThread().getName() + "\t离开");
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    semaphore.release();
                }
            }, String.valueOf(i)).start();
        }
    }
}
/*
2	抢到车位!
1	抢到车位!
6	抢到车位!
1	离开
6	离开
4	抢到车位!
3	抢到车位!
3	离开
5	抢到车位!
2	离开
4	离开
5	离开
*/
posted @ 2020-12-15 18:01  夜小十五天  阅读(112)  评论(0编辑  收藏  举报