java多线程JUC常用辅助类详解

让我们来详细讲解“java多线程JUC常用辅助类详解”的攻略。

一、JUC简介

JUC（Java Util Concurrent）是Java SE 5中推出的一个并发编程框架，提供了许多特殊的并发编程工具类，以及对Java线程池的支持等。

二、JUC常用函数

以下是JUC中常用的辅助类：

1. CountDownLatch（倒计数器）

CountDownLatch是一个同步辅助类，它允许一个或多个线程等待其他线程完成操作，然后再执行。

CountDownLatch内部有一个计数器，这个计数器初始值设定为线程数（通过构造函数设置）。当一个线程完成了自己的任务后，计数器的值就减1，当计数器减为0时，所有线程才会继续执行。

示例

public class CountDownLatchTest {
    public static void main(String[] args) throws InterruptedException{
        CountDownLatch startSignal = new CountDownLatch(1);
        CountDownLatch doneSignal = new CountDownLatch(5);
        for (int i = 0; i < 5; ++i) {
            new Thread(new Worker(startSignal, doneSignal)).start();
        }
        System.out.println("工人准备就绪，开始干活！");
        startSignal.countDown();
        doneSignal.await();
        System.out.println("工作完成，收工！");
    }
}

class Worker implements Runnable {
    private final CountDownLatch startSignal;
    private final CountDownLatch doneSignal;
    Worker(CountDownLatch startSignal, CountDownLatch doneSignal) {
        this.startSignal = startSignal;
        this.doneSignal = doneSignal;
    }
    public void run() {
        try {
            startSignal.await(); // 线程阻塞，等待主线程计数器变为0后，一起执行
            work();
            doneSignal.countDown(); // 完成后计数器减1
        } catch (InterruptedException ex) {
            // ...
        }
    }
    void work() throws InterruptedException {
        System.out.println(Thread.currentThread().getName() + " is working");
        Thread.sleep(1000); // 模拟工作
    }
}

2. CyclicBarrier（循环屏障）

CyclicBarrier也是一种同步工具类，它会阻塞几个线程直到它们都到达某个状态后才开始执行，与CountDownLatch的区别是，CyclicBarrier可以用于多线程间互相等待。

当所有线程都调用await()方法时，所有线程才会继续执行。

示例

public class CyclicBarrierTest {
    public static void main(String[] args) throws InterruptedException, BrokenBarrierException{
        CyclicBarrier barrier = new CyclicBarrier(3, new Runnable() { // 所有线程达到屏障后执行的操作
            @Override
            public void run() {
                System.out.println("GO!");
            }
        });

        new Thread(new Task(barrier)).start();
        new Thread(new Task(barrier)).start();
        new Thread(new Task(barrier)).start();
    }
}

class Task implements Runnable {
    private final CyclicBarrier barrier;
    Task(CyclicBarrier barrier) {
        this.barrier = barrier;
    }
    public void run() {
        try {
            Thread.sleep(1000);
            System.out.println(Thread.currentThread().getName() + " is ready!");
            barrier.await(); // 等待其他线程到达屏障
            System.out.println(Thread.currentThread().getName() + " is executing!");
        } catch (InterruptedException ex) {
            // ...
        } catch (BrokenBarrierException ex) {
            // ...
        }
    }
}

3. Semaphore（信号量）

Semaphore是一种控制访问资源的同步工具，用于控制同时访问某个资源的线程数量。

Semaphore有两种模式：公平模式和非公平模式。在公平模式下，Semaphore会根据线程的等待时间来分配许可证；在非公平模式下，Semaphore会随机分配许可证。

Semaphore可以用于控制并发线程的数量，例如限制最大并发数。

示例

public class SemaphoreTest {
    public static void main(String[] args) throws InterruptedException {
        Semaphore semaphore = new Semaphore(2); // 允许两个线程同时执行
        for (int i = 1; i <= 5; ++i) {
            new Thread(new Task(semaphore, i)).start();
        }
    }
}

class Task implements Runnable {
    private final Semaphore semaphore;
    private final int id;
    Task(Semaphore semaphore, int id) {
        this.semaphore = semaphore;
        this.id = id;
    }
    public void run() {
        try {
            semaphore.acquire(); // 获取一个许可证
            System.out.println(Thread.currentThread().getName() + " acquire semaphore " + id);
            Thread.sleep(1000);
        } catch (InterruptedException ex) {
            // ...
        } finally {
            semaphore.release(); // 释放一个许可证
            System.out.println(Thread.currentThread().getName() + " release semaphore " + id);
        }
    }
}

三、JUC的优点

在使用JUC的辅助类时，我们可以获得以下几个优点：

• 可以提高程序的运行效率；
• 可以减少程序的资源消耗，提高程序性能；
• 可以更好地管理和控制多线程程序，减少线程间的竞争和冲突。

综上所述，JUC提供了一些强大的辅助类，可以用来控制线程的运行，提高程序的运行效率和性能。在实际使用中，根据不同的需求和场景可以采用不同的辅助类进行程序设计。