查看原文
其他

面试官必问:Java中的JUC工具类详细揭秘

脚本之家 2023-12-27

The following article is from Java技术指北 Author 了不起


将 脚本之家 设为“星标
第一时间收到文章更新

来源丨Java技术指北(ID:javanorth)

已获得原公众号授权转载

JUC - 辅助类

JUC(java.util.concurrent)是在Java 5中引入的一个并发编程的扩展库,目的是为了更加方便、快捷和安全地实现并发编程。它提供了一系列的工具类、锁、队列以及原子类等来协调多线程之间的操作。

基于现代硬件不断地发展,为了充分利用服务器资源,并发编程在我们的开发中已经无处不在,今天主要了解下JUC包中提供的几个工具类,让我们在并发编程时提供助力。

简介

Java并发编程是一门复杂的技术,其中有一些难点需要特别注意。以下是一些Java并发编程的难点:

  • 线程安全:多线程执行的代码必须是线程安全的,否则会产生竞态条件和其他问题。

  • 死锁:当多个线程因为互相等待其他线程释放锁而无法继续执行时,就会产生死锁。

  • 竞态条件:当多个线程试图同时访问同一个共享资源时,就会产生竞态条件。

  • 内存可见性:多个线程同时访问同一个变量时,可能会产生内存可见性问题,即一个线程对变量的修改不会立即被其他线程所感知。

  • 并发集合类:Java提供了一些并发集合类,如ConcurrentHashMap和ConcurrentLinkedQueue,但使用它们需要注意一些细节问题。

  • 线程池:线程池是Java并发编程中的一个重要概念,但线程池的使用也需要注意一些问题,如线程池大小、任务队列类型等。

  • CAS操作:Java提供了CAS(Compare-And-Swap)操作,可以用于实现非阻塞算法,但使用CAS操作需要非常小心,以免产生ABA问题等。

工具类

  • CountDownLatch
    CountDownLatch是一个同步辅助类,使用一个给定数量的计数器,当该计数器不为0时,将程序阻塞在wait()处,当线程执行完成后通过调用countDown()使计数器减一, 直到计数器为0后才会继续执行后续代码。 主要实现某个任务依赖其他一个或多个异步任务的执行结果的场景

核心方法:

/**
 * 定义计数器数量,用于定义多少个执行线程
 */

public CountDownLatch(int count);
/**
 * 阻塞方法,直到计数器为0时才会继续执行后续代码
 */

public void await();
/**
 * 每次调用改方法,则计数器减一
 */

public void countDown();
  • CyclicBarrier
    CyclicBarrier内部同样定义了计数器,只不过每当有线程执行完后改计数器加一,直至达到定义数量后,执行定义的回调函数与await()后续代码。与CountDownLatch相比,CyclicBarrier会对子任务阻塞,而CountDownLatch则阻塞主任务;另外CyclicBarrier可以重复使用。 主要实现某个回调函数在一个或多个线程执行完成后触发的情形

核心方法:

/**
 * 定义计数器数量与回调函数
 */

public CyclicBarrier(int parties, Runnable barrierAction);
/**
 * 阻塞方法,当有线程执行到则计数器加一,等到达到目标数后才会继续后续代码
 */

public int await();
/**
 * 通过该方法可以实现计数器的重置
 */

public void reset();
  • Semaphore
    信号量通常用于限制可以访问某些(物理或逻辑)资源的线程数。 适用于有限资源数量的控制

核心方法:

/**
 * 定义许可数量
 */

public Semaphore(int permits);
/**
 * 申请许可,改方法会阻塞程序
 */

public void acquire();
/**
 * 释放许可
 */

public void release();

示例

CountDownLatch的使用场景

CountDownLatch是Java并发包中的一个工具类,它可以实现线程之间的协作。具体来说,CountDownLatch可以让一个线程等待多个线程执行完毕,再继续执行。CountDownLatch常用于以下场景:

  1. 主线程等待多个子线程执行完毕。
  2. 多个子线程等待某个共同任务的完成。
  3. 模拟并发请求,等待所有请求都响应完毕再进行下一步操作。
  4. 统计多个线程执行的时间。
    @Test
    public void test() throws InterruptedException {
        int count = 10;
        CountDownLatch countDownLatch = new CountDownLatch(count);
        IntStream.range(0,count).forEach(i->{
            new Thread(()->{
                System.out.println( "执行线程:"+ i );
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                countDownLatch.countDown();
            }).start();
        });

        countDownLatch.await();

        System.out.println("线程执行完成");
    }

CyclicBarrier的使用场景

它允许多个线程在某个屏障处等待,直到所有线程都到达该屏障时才会继续执行。

CyclicBarrier 适用于一组线程需要相互等待,直到所有线程都完成某个任务后才能继续执行下一步操作的场景。例如,一个大型的计算任务可以被分成多个子任务, 每个子任务由一个线程执行。当所有子任务完成后,这些线程需要等待,直到所有子任务都完成,然后再执行下一步操作。

另外,CyclicBarrier 还可以用于优化代码性能。例如,当我们需要等待多个线程都完成某项工作后,才能进行下一步操作。此时,我们可以使用 CyclicBarrier 来实现等待, 而不是使用 Thread.sleep() 方法等待一段时间。这样可以避免无谓的等待时间,提高代码效率。

@Test
    public void test() {
        int count = 10;
        AtomicBoolean finish = new AtomicBoolean(false);
        CyclicBarrier cyclicBarrier = new CyclicBarrier(count, ()->{
            System.out.println("线程执行完成");
            finish.set(true);
        });

        IntStream.range(0,count).forEach(i->{
            new Thread(()->{
                System.out.println( "执行线程:"+ i );
                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                try {
                    cyclicBarrier.await();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                } catch (BrokenBarrierException e) {
                    throw new RuntimeException(e);
                }
            }).start();
        });

        while (!finish.get()){}
    }

Semaphore的使用场景

它可以控制同时访问某个共享资源的线程数量。常用于限制同时访问某个资源的线程数量,例如数据库连接池、线程池等。

  1. 控制并发线程数:Semaphore可以限制并发线程数,从而控制系统资源的使用情况。
  2. 控制访问资源数:Semaphore可以控制同时访问某个资源的线程数量,例如数据库连接池,限制连接数。
  3. 实现生产者-消费者模型:Semaphore可以与阻塞队列一起使用,实现生产者-消费者模型,控制生产者和消费者的数量。
  4. 多个线程间的协作:Semaphore可以用于多个线程之间的协作,例如某个线程需要等待某些条件满足后才能继续执行,可以使用Semaphore来实现等待和唤醒操作。
    @Test
    public void test() {
        int count = 10;

        Semaphore semaphore = new Semaphore(3);

        IntStream.range(0,count).forEach(i->{
            new Thread(()->{
                try {
                    semaphore.acquire();
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

                System.out.println( "执行线程:"+ i );

                try {
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }

                semaphore.release();
            }).start();
        });

        while (true){}
    }

结束语

涉及到线程的开发都伴随着复杂性,不管是在代码调试上还是理解线程切换与安全性上,JUC提供的各种强大的工具类将并发编程的复杂性进行了封装,不管是在使用或是扩展上,都能通过简单的几行代码实现多线程的各种协调工作。


  推荐阅读:
  1. C++ 太卷,转 Java?
  2. Java 17采用率四倍飙升
  3. 公司技术最好的程序员,被优化了...
  4. 70年前他本想逃避考试,却影响了整个互联网
  5. 我程序会死在这一行,是什么原因?
继续滑动看下一个

您可能也对以下帖子感兴趣

文章有问题?点此查看未经处理的缓存