18-JUC

原创已于 2023-08-29 09:19:46 修改 · 249 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

于 2023-03-14 08:08:45 首次发布

多线程专栏收录该内容

19 篇文章

订阅专栏

本文介绍了Java并发编程中四个重要的工具：ReentrantLock（可重入锁）、Semaphore（信号量，用于限流和控制并发量）、CountDownLatch（计数器，等待所有线程完成）和CyclicBarrier（循环屏障，用于线程分组的同步）。每个工具的使用方法和应用场景都有详细阐述，例如Semaphore可用于限制并发访问的资源数量，CountDownLatch适用于等待一组线程完成，而CyclicBarrier则用于多线程协同工作。

PS：Semaphore、CountDownLatch、CyclicBarrier 的区别

java.util.concurrent 下的类就叫 JUC 类，JUC 下典型的类有：

ReentrantLock
Semaphore
CountDownLatch
CyclicBarrier

1.ReentrantLock：可重入锁

之前文章有详解：加锁&释放锁~

2.Semaphore：信号量

设置传参表示颁发了几个令牌。可以做程序的限流操作。控制并发量。

acquire()：尝试获得令牌，如果没有令牌，会阻塞。
release()：令牌不用了，释放令牌。

import java.time.LocalDateTime;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.concurrent.TimeUnit;

/**
 * 信号量：实现限流
 */
public class SemaphoreDemo1 {
    public static void main(String[] args) {
        //创建线程池
        ExecutorService service = Executors.newFixedThreadPool(5);

        //创建信号量，默认情况下也是非公平锁【若要设置公平锁，只需要设置第二个参数true】
        Semaphore semaphore = new Semaphore(2); //表示同时可以一起执行的线程只有2个

        //统一任务的定义
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                Thread currentThread = Thread.currentThread(); //得到执行此任务的线程
                System.out.println("进入线程：" + currentThread.getName());
                try {
                    //获取令牌
                    semaphore.acquire(); //如果没有可用令牌的话，那么线程会阻塞在当前位置
                    System.out.println(currentThread.getName() + ":得到了令牌 | Time：" + LocalDateTime.now());
                    TimeUnit.SECONDS.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } finally{
                    System.out.println(currentThread.getName() + ":释放了令牌 | Time：" + LocalDateTime.now());
                    //释放令牌
                    semaphore.release();
                }
            }
        };

        //定义新线程执行任务
        service.submit(runnable);

        //定义新线程执行任务
        service.submit(runnable);

        //定义新线程执行任务
        service.submit(runnable);

        //定义新线程执行任务
        service.submit(runnable);

        //定义新线程执行任务
        service.submit(runnable);
    }
}

公平锁：

import java.time.LocalDateTime;
import java.util.concurrent.Semaphore;

/**
 * 信号量：实现限流
 * 通过使用 Semaphore，可以控制同时执行的线程数量，限制系统的负载或资源的使用。
 * 在这个示例中，信号量的初始令牌数量为10，因此最多允许同时执行10个线程，其他线程需要等待令牌被释放后才能继续执行。
 * 公平性设置为 true，代表使用公平锁，保证了线程获取令牌的顺序与申请令牌的顺序相同。
 */
public class SemaphoreDemo1 {
    public static void main(String[] args) {
        //创建一个信号量（Semaphore）对象，通过构造函数传递两个参数：初始令牌数量和公平性（是否使用公平锁）
        //默认情况下也是非公平锁【若要设置公平锁，只需要设置第二个参数true】
        Semaphore semaphore = new Semaphore(10, true);

        //使用一个循环创建了1000个线程，并在每个线程中进行以下操作
        for (int i = 0; i < 1000; i++) {
            try {
                //通过 Thread.sleep 方法延迟一段时间，模拟不同线程的不同执行速度
                Thread.sleep(i * 100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            //创建一个新的线程，并在其中定义了一个匿名的 Runnable 对象
            new Thread(new Runnable() {
                @Override
                public void run() {
                    Thread currentThread = Thread.currentThread();//得到执行此任务的线程
                    try {
                        //首先获取令牌，如果没有可用的令牌，则当前线程会阻塞在此位置。
                        semaphore.acquire();
                        //在获取到令牌后，打印一条信息表示当前线程获取到了令牌，并输出当前时间
                        System.out.println(currentThread.getName() + ":得到了令牌 | Time：" + LocalDateTime.now());
                        //延迟500毫秒，表示线程正在执行一些任务
                        Thread.sleep(500);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } finally {
                        //释放令牌
                        semaphore.release();
                    }
                }
            }).start();
        }
    }
}

非公平锁：

Semaphore semaphore = new Semaphore(10, false);

3.CountDownLatch：计数器

等待所有线程都执⾏完： join方法。
等待所有线程池都执⾏完：CountDownLatch方法。

CountDownLatch方法：判断线程池的任务是否已经全部执行完，线程安全的。其中有2个方法：

countDown：执行计数器-1操作。
await：阻塞等待，所有的任务全部执行完（等待CountDownLatch = 0，继续执行后面的代码）。

import java.util.Random;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

/**
 * 计数器使用
 */
public class CountDownLatchDemo1 {
    public static void main(String[] args) throws InterruptedException {
        //创建计数器
        CountDownLatch countDownLatch = new CountDownLatch(5); //参加任务的数量

        //创建线程池
        ExecutorService service = Executors.newFixedThreadPool(5);

        //创建新线程执行任务
        for (int i = 1; i < 6; i++) {
            service.submit(() -> {
                Thread currThread = Thread.currentThread();
                System.out.println(currThread.getName() + "开始起跑");
                //跑步所用时间 1 + (0 - 4) 最长跑5s，最短跑1s
                int runTime = (1 + new Random().nextInt(5));
                try {
                    TimeUnit.SECONDS.sleep(runTime);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(currThread.getName() + "：到达终点。用时：" + runTime);
                countDownLatch.countDown(); //计数器-1
            });
        }

        countDownLatch.await();//阻塞等待，直到线程执行完
        System.out.println("比赛结果宣布");
    }
}

4.CyclicBarrier：循环屏障

CyclicBarrier可以看做是一个可以重复利用的CountDownLatch（一次性的），可实现线程分组的阻塞。其中的1个重要方法：

await：计数器-1，判断当前计数器是否为0，如果为0，冲破屏障执行之后的代码；否则阻塞等待，直到屏障被冲破。

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 循环屏障
 */
public class CyclicBarrierDemo1 {
    public static void main(String[] args) {
        //创建了一个循环屏障（CyclicBarrier）对象，通过构造函数传递两个参数：参与线程数和在所有线程都到达屏障时需要执行的操作（作为一个 Runnable 对象）
        CyclicBarrier cyclicBarrier = new CyclicBarrier(5, new Runnable() {
            @Override
            public void run() {
                System.out.println("计数器为0了");
            }
        });

        //创建一个固定大小为10的线程池
        ExecutorService service = Executors.newFixedThreadPool(10);

        //使用一个循环创建了10个任务，并通过线程池提交执行
        for (int i = 0; i < 10; i++) {
            int finalI = i;
            service.submit(() -> {
                Thread currThread = Thread.currentThread();
                System.out.println("执行线程：" + currThread.getName());
                try {
                    //线程休眠一段时间（毫秒数由变量 finalI 决定，用于模拟不同任务的执行时间）
                    Thread.sleep(5 * finalI);
                    //执行阻塞等待。该方法会将屏障计数器减1，并阻塞当前线程，直到所有线程都到达屏障时，屏障计数器为0，才会继续执行后面的代码。
                    cyclicBarrier.await(); 
                } catch (InterruptedException e) {
                    e.printStackTrace();
                } catch (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println("线程执行完成：" + currThread.getName());
            });
        }
    }
}

PS：Semaphore、CountDownLatch、CyclicBarrier 的区别

Semaphore、CountDownLatch 和 CyclicBarrier 是 Java 多线程编程中的三种并发控制工具，它们之间有以下区别：

1. 功能不同：

Semaphore：用于控制同时访问某个资源的线程数量。
CountDownLatch：用于等待一组线程完成后再执行某个任务。
CyclicBarrier：用于让一组线程达到一个屏障（Barrier）时进行等待，然后同时执行后续操作。

2. 使用方式不同：

Semaphore：通过 acquire() 方法获取令牌，release() 方法释放令牌。
CountDownLatch：通过 await() 方法等待计数器减到 0，然后继续执行。
CyclicBarrier：通过 await() 方法等待所有线程到达屏障，然后同时执行后续操作。

3. 计数器方式不同：

Semaphore：通过维护一个计数器来控制访问资源的线程数量，线程获取到信号量时计数器减1，释放信号量时计数器加1。
CountDownLatch：通过维护一个计数器来控制等待完成的线程数量，计数器初始值为线程数，每个线程完成任务时计数器减1，当计数器减至0时释放等待的线程。
CyclicBarrier：通过维护一个计数器来控制等待的线程数量，并定义一个屏障操作。每个线程调用 await() 方法时计数器减1，当计数器减至0时，所有线程同时执行屏障操作，然后计数器重置。

4. 重复使用性不同：

Semaphore：可以重复使用，内部计数器可以反复加减。
CountDownLatch：不可重复使用，计数器减到0后无法重置。
CyclicBarrier：可重复使用，计数器减到0后会自动重置计数器，可以再次使用。

5. 适用场景不同：

Semaphore：适用于限制并发访问的资源数量，如连接池、线程池等。
CountDownLatch：适用于等待一组线程完成后执行主线程的任务，如并行任务的结果收集。
CyclicBarrier：适用于多线程协同工作，必须等到所有线程都到达一个状态时再继续执行后续操作，如并行计算任务的结果归并。