JUC并发工具类在大厂的应用场景详解

        jdk提供了比synchronized更加高级的各种同步工具,包括 ReentrantLock Semaphore CountDownLatch 、 CyclicBarrier等,可以实现更加丰富的多线程操作。
(前三个是重点)
JUC并发工具类在大厂的应用场景详解_第1张图片

        一. ReentrantLock

        ReentrantLock是一种可重入的独占锁,它允许同一个线程多次获取同一个锁而不会被阻塞。 它的功能类似于synchronized是一种互斥锁,可以保证线程安全。相对于 synchronized, ReentrantLock具备如下特点:

        1.1 可中断

        1.2 可以设置超时时间

        1.3 可以设置为公平锁(默认非公平锁)
        1.4 支持多个条件变量
        1.5 与 synchronized 一样,都支持可重入
它的主要应用场景是 在多线程环境下对共享资源进行独占式访问,以保证数据的一致性和安全性。
        常用API
void lock()
获取锁,调用该方法当前线程会获取锁,当锁获
得后,该方法返回
void lockInterruptibly()
可中断的获取锁,和lock()方法不同之处在于该方
法会响应中断,即在锁的获取中可以中断当前线
boolean tryLock()
尝试非阻塞的获取锁,调用该方法后立即返回。
如果能够获取到返回true,否则返回false
boolean tryLock(long time, TimeUnit unit)
超时获取锁,当前线程在以下三种情况下会被返
回:
当前线程在超时时间内获取了锁
当前线程在超时时间内被中断
超时时间结束,返回false
void unlock()
释放锁
Condition newCondition()
获取等待通知组件,该组件和当前的锁绑定,当 前线程只有获取了锁,才能调用该组件的await() 方法,而调用后,当前线程将释放锁

注意点:   

        1. 默认情况下 ReentrantLock 为非公平锁而非公平锁;
        2. 加锁次数和释放锁次数一定要保持一致,否则会导致线程阻塞或程序异常;
        3. 加锁操作一定要放在 try 代码之前,这样可以避免未加锁成功又释放锁的异常;
        4. 释放锁一定要放在 finally 中,否则会导致线程阻塞。

        1.1 ReentrantLock使用

        独占锁:模拟抢票场景

package com.laoyang.Thread;

import java.util.concurrent.locks.ReentrantLock;

/**
 * @author:Kevin
 * @create: 2023-10-11 18:17
 * @Description: 模拟抢票
 */

public class ReentrantLockDemo {
    private final ReentrantLock lock = new ReentrantLock();//默认非公平
    private static int tickets = 8; // 总票数

    public void buyTicket() {
        lock.lock(); // 获取锁
        try {
            if (tickets > 0) { // 还有票
                try {
                    Thread.sleep(10); // 休眠10ms,模拟出并发效果
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "购买了第" +
                        tickets-- + "张票");
            } else {
                System.out.println("票已经卖完了," + Thread.currentThread().getName() +
                        "抢票失败");
            }

        } finally {
            lock.unlock(); // 释放锁
        }
    }


    public static void main(String[] args) {
        ReentrantLockDemo ticketSystem = new ReentrantLockDemo();
        for (int i = 1; i <= 10; i++) {
            Thread thread = new Thread(() -> {

                ticketSystem.buyTicket(); // 抢票

            }, "线程" + i);
            // 启动线程
            thread.start();

        }


        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
        System.out.println("剩余票数:" + tickets);
    }
}

JUC并发工具类在大厂的应用场景详解_第2张图片        

       1.2 公平锁和非公平锁

        ReentrantLock支持公平锁和非公平锁两种模式:

        公平锁:线程在获取锁时,按照等待的先后顺序获取锁。

        非公平锁:线程在获取锁时,不按照等待的先后顺序获取锁,而是随机获取锁。ReentrantLock默认是非公平锁
JUC并发工具类在大厂的应用场景详解_第3张图片
        比如买票的时候就有可能出现插队的场景,允许插队就是非公平锁,如下图:
JUC并发工具类在大厂的应用场景详解_第4张图片

        1.3 结合Condition实现生产者消费者模式

java.util.concurrent类库中提供Condition类来实现线程之间的协调。调用Condition.await() 方法使
线程等待,其他线程调用Condition.signal() 或 Condition.signalAll() 方法唤醒等待的线程。
注意: 调用Condition的await()和signal()方法,都必须在lock保护之内。
案例:基于ReentrantLock和Condition实现一个简单队列
package com.laoyang.Thread;


import java.util.Random;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

/**
 * @author:Kevin
 * @create: 2023-10-11 18:29
 * @Description: 模拟生产消费场景
 */

public class ReentrantLockDemo3 {

    public static void main(String[] args) {
        // 创建队列
        Queue queue = new Queue(5);
        //启动生产者线程
        new Thread(new Producer(queue)).start();
        //启动消费者线程
        new Thread(new Customer(queue)).start();
    }

    public static class Queue {
        private Object[] items;
        int size = 0;
        int takeIndex;
        int putIndex;
        private ReentrantLock lock;
        public Condition notEmpty; //消费者线程阻塞唤醒条件,队列为空阻塞,生产者生产完唤醒
        public Condition notFull; //生产者线程阻塞唤醒条件,队列满了阻塞,消费者消费完唤醒

        public Queue(int capacity) {
            this.items = new Object[capacity];
            lock = new ReentrantLock();
            notEmpty = lock.newCondition();
            notFull = lock.newCondition();
        }


        public void put(Object value) throws Exception {
            //加锁
            lock.lock();
            try {
                while (size == items.length)
                    // 队列满了让生产者等待
                    notFull.await();

                items[putIndex] = value;
                if (++putIndex == items.length)
                    putIndex = 0;
                size++;
                notEmpty.signal(); // 生产完唤醒消费者

            } finally {
                System.out.println("producer生产:" + value);
                //解锁
                lock.unlock();
            }
        }

        public Object take() throws Exception {
            lock.lock();
            try {
                // 队列空了就让消费者等待
                while (size == 0)
                    notEmpty.await();

                Object value = items[takeIndex];
                items[takeIndex] = null;
                if (++takeIndex == items.length)
                    takeIndex = 0;
                size--;
                notFull.signal(); //消费完唤醒生产者生产
                return value;
            } finally {
                lock.unlock();
            }
        }
    }

    static class Producer implements Runnable {

        private Queue queue;

        public Producer(Queue queue) {
            this.queue = queue;
        }

        @Override
        public void run() {
            try {
                // 隔1秒轮询生产一次
                while (true) {
                    Thread.sleep(1000);
                    queue.put(new Random().nextInt(1000));
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 101 * 消费者
     * 102
     */
    static class Customer implements Runnable {

        private Queue queue;

        public Customer(Queue queue) {
            this.queue = queue;
        }

        @Override
        public void run() {
            try {
                // 隔2秒轮询消费一次
                while (true) {
                    Thread.sleep(2000);
                    System.out.println("consumer消费:" + queue.take());
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }


}
1.3 应用场景总结
        
ReentrantLock具体应用场景如下:
        1. 解决多线程竞争资源的问题,例如多个线程同时对同一个数据库进行写操作,可以使用ReentrantLock保证每次
只有一个线程能够写入。
        2. 实现多线程任务的顺序执行,例如在一个线程执行完某个任务后,再让另一个线程执行任务。
        3. 实现多线程等待/通知机制,例如在某个线程执行完某个任务后,通知其他线程继续执行任务。

        二. Semaphore 

        Semaphore(信号量)是一种用于多线程编程的同步工具,用于控制同时访问某个资源的线程数量

JUC并发工具类在大厂的应用场景详解_第5张图片

        Semaphore维护了一个计数器,线程可以通过调用acquire()方法来获取Semaphore中的许可证,当计数器为0时,调用acquire()的线程将被阻塞,直到有其他线程释放许可证;线程可以通过调用release()方法来释放Semaphore中的许可证,这会使Semaphore中的计数器增加,从而允许更多的线程访问共享资源。

2.1 常用方法

acquire() 表示阻塞并获取许可
tryAcquire() 方法在没有许可的情况下会立即返回 false,要获取许可的线程不会阻塞
release() 表示释放许可

2.2 Semaphore实现服务接口限流

package com.laoyang.Thread;

import java.util.concurrent.Executor;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

/**
 * @author:Kevin
 * @create: 2023-10-11 18:48
 * @Description: 模拟限流操作
 */

public class SemaphoreDemo {

    //信号量
    private static Semaphore semaphore = new Semaphore(2);

    private static Executor executor = Executors.newFixedThreadPool(10);


    public static void main(String[] args) {
        for(int i=0;i<10;i++){
             executor.execute(()->getProductInfo2());
        }
    }

    public static String getProductInfo2() {

         if(!semaphore.tryAcquire()){
             System.out.println("请求被流控了");
             return "请求被流控了";
             }
         try {
             System.out.println("请求服务");
             Thread.sleep(2000);
             } catch (InterruptedException e) {
             throw new RuntimeException(e);
             }finally {
             semaphore.release();
             }
         return "返回商品详情信息";
         }
}

2.3 应用场景总结

        以下是一些使用Semaphore的常见场景:
        1. 限流:Semaphore可以用于限制对共享资源的并发访问数量,以控制系统的流量。
        2. 资源池:Semaphore可以用于实现资源池,以维护一组有限的共享资源。

        

        三. CountDownLatch 

        CountDownLatch(闭锁)是一个同步协助类,允许一个或多个线程等待,直到其他线程完成操作集。

JUC并发工具类在大厂的应用场景详解_第6张图片

        CountDownLatch使用给定的计数值(count)初始化。await方法会阻塞直到当前的计数值 (count),由于countDown方法的调用达到0,count为0之后所有等待的线程都会被释放,并且随后对await方法的调用都会立即返回。这是一个一次性现象 —— count不会被重置。

        3.1 常用方法

void await ()
调用 await() 方法的线程会被挂起,它会等待直到 count 值为 0 才继续执行
boolean await ( long timeout , TimeUnit unit )
await() 类似,若等待 timeout 时长后, count 值还是没有变为 0 ,不再等待,继续执行
void countDown ()
会将 count 1 ,直至为 0

        3.2 CountDownLatch使用

        模拟实现百米赛跑

package com.laoyang.Thread;

import java.util.concurrent.CountDownLatch;

/**
 * @author:Kevin
 * @create: 2023-10-11 18:59
 * @Description: 模拟实现百米赛跑
 */

public class CountDownLatchDemo {

    // begin 代表裁判 初始为 1
    private static CountDownLatch begin = new CountDownLatch(1);

    // end 代表玩家 初始为 8
    private static CountDownLatch end = new CountDownLatch(8);


    public static void main(String[] args) throws InterruptedException {
        for (int i = 1; i <= 8; i++) {
             new Thread(new Runnable() {
                @Override
                public void run() {
                    // 预备状态
                    System.out.println("参赛者" + Thread.currentThread().getName() + "已经准备好了");
                    // 等待裁判吹哨
                    try {
                        begin.await();
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    // 开始跑步
                    System.out.println("参赛者" + Thread.currentThread().getName() + "开始跑步");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    // 跑步结束, 跑完了
                    System.out.println("参赛者" + Thread.currentThread().getName() + "到达终点");
                            // 跑到终点, 计数器就减一
                            end.countDown();
                }
            }).start();
        }
        // 等待 5s 就开始吹哨
        Thread.sleep(5000);
        System.out.println("开始比赛");
        // 裁判吹哨, 计数器减一
        begin.countDown();
        // 等待所有玩家到达终点
        end.await();
        System.out.println("比赛结束");
    }
}

        多任务完成后合并汇总

        很多时候,我们的并发任务,存在前后依赖关系;比如数据详情页需要同时调用多个接口获取数据,并发请求获取到数据后、需要进行结果合并;或者多个数据操作完成后,需要数据check。

package com.laoyang.Thread;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ThreadLocalRandom;

/**
 * @author:Kevin
 * @create: 2023-10-11 19:10
 * @Description: 多任务完成后合并汇总
 */

public class CountDownLatchDemo2 {

    public static void main(String[] args) throws Exception {
        CountDownLatch countDownLatch = new CountDownLatch(5);
        for (int i = 0; i < 5; i++) {
            final int index = i;
            new Thread(() -> {
                try {
                    Thread.sleep(1000 + ThreadLocalRandom.current().nextInt(2000));
                    System.out.println("任务" + index + "执行完成");
                    countDownLatch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }).start();
        }

        // 主线程在阻塞,当计数器为0,就唤醒主线程往下执行
        countDownLatch.await();
        System.out.println("主线程:在所有任务运行完成后,进行结果汇总");

    }
}

3.3 应用场景总结

以下是使用CountDownLatch的常见场景:
         1. 并行任务同步:CountDownLatch可以用于协调多个并行任务的完成情况,确保所有任务都完成后再继续执行下
一步操作。
        2. 多任务汇总:CountDownLatch可以用于统计多个线程的完成情况,以确定所有线程都已完成工作。
        3. 资源初始化:CountDownLatch可以用于等待资源的初始化完成,以便在资源初始化完成后开始使用。

          四. CyclicBarrier

        CyclicBarrier(回环栅栏或循环屏障),是 Java 并发库中的一个同步工具,通过它可以实现让一组线程等待至某个状态(屏障点)之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后,CyclicBarrier可以被重用。

JUC并发工具类在大厂的应用场景详解_第7张图片JUC并发工具类在大厂的应用场景详解_第8张图片

        4.1 常用方法

int await ()
指定数量的线程全部调用 await() 方法时,这些线程不再阻塞
int await ( long timeout , TimeUnit unit )
BrokenBarrierException 表示栅栏已经被破坏,破坏的原因可能是其中一个线程 await() 时被中断
或者超时
void reset ()
循环 通过 reset() 方法可以进行重置

        4.2 CyclicBarrier使用

        利用CyclicBarrier的计数器能够重置,屏障可以重复使用的特性,可以支持类似“人满发车”的场景

package com.laoyang.Thread;

import java.util.concurrent.*;

/**
 * @author:Kevin
 * @create: 2023-10-11 19:20
 * @Description:模拟人满发车
 */

public class CyclicBarrierDemo {
    public static void main(String[] args) {

        ExecutorService executorService = Executors.newFixedThreadPool(5);
        
        CyclicBarrier cyclicBarrier = new CyclicBarrier(5,
                () -> System.out.println("人齐了,准备发车"));

        for (int i = 0; i < 10; i++) {
            final int id = i + 1;
            executorService.submit(new Runnable() {
                @Override
                public void run() {
                    try {
                        System.out.println(id + "号马上就到");
                        int sleepMills = ThreadLocalRandom.current().nextInt(2000);
                        Thread.sleep(sleepMills);
                        System.out.println(id + "号到了,上车");
                        cyclicBarrier.await();

                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    } catch (BrokenBarrierException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
    }
}

4.3 应用场景总结

以下是一些常见的 CyclicBarrier 应用场景:
        1. 多线程任务:CyclicBarrier 可以用于将复杂的任务分配给多个线程执行,并在所有线程完成工作后触发后续操
作。
        2. 数据处理:CyclicBarrier 可以用于协调多个线程间的数据处理,在所有线程处理完数据后触发后续操作。

4.4 CyclicBarrier 与 CountDownLatch 区别

        1. CountDownLatch 是一次性的,CyclicBarrier 是可循环利用的
        2. CountDownLatch 参与的线程的职责是不一样的,有的在倒计时,有的在等待倒计时结束。CyclicBarrier 参与的线程职责是一样的。

        五. Exchanger 

        Exchanger是一个用于线程间协作的工具类,用于两个线程间交换数据。具体交换数据是通过exchange方法来实现的,如果一个线程先执行exchange方法,那么它会同步等待另一个线程也执行 exchange方法,这个时候两个线程就都达到了同步点,两个线程就可以交换数据。

JUC并发工具类在大厂的应用场景详解_第9张图片

        5.1 Exchanger使用

        模拟交易场景

用一个简单的例子来看下Exchanger的具体使用。两方做交易,如果一方先到要等另一方也到了才能交易,交易就是执行exchange方法交换数据。
package com.laoyang.Thread;

import java.util.concurrent.Exchanger;

/**
 * @author:Kevin
 * @create: 2023-10-11 19:25
 * @Description: 模拟交换
 */

public class ExchangerDemo {
    private static Exchanger exchanger = new Exchanger();
    static String goods = "电脑";
    static String money = "$4000";

    public static void main(String[] args) throws InterruptedException {
        System.out.println("准备交易,一手交钱一手交货...");
        // 卖家
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("卖家到了,已经准备好货:" + goods);
                try {
                    String money = (String) exchanger.exchange(goods);
                    System.out.println("卖家收到钱:" + money);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();

        Thread.sleep(3000);

        // 买家
        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    System.out.println("买家到了,已经准备好钱:" + money);
                    String goods = (String) exchanger.exchange(money);
                    System.out.println("买家收到货:" + goods);
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }).start();

    }
}

        5.2 应用场景总结

        Exchanger 可以用于各种应用场景,具体取决于具体的 Exchanger 实现。常见的场景包括:

        1. 数据交换:在多线程环境中,两个线程可以通过 Exchanger 进行数据交换。

        2. 数据采集:在数据采集系统中,可以使用 Exchanger 在采集线程和处理线程间进行数据交换。

        六. Phaser  

        Phaser(阶段协同器)是一个Java实现的并发工具类,用于协调多个线程的执行。它提供了一些方便的方法来管理多个阶段的执行,可以让程序员灵活地控制线程的执行顺序和阶段性的执行。Phaser可以被视为CyclicBarrier和CountDownLatch的进化版,它能够自适应地调整并发线程数,可以动态地增加或减少参与线程的数量。所以Phaser特别适合使用在重复执行或者重用的情况。

你可能感兴趣的:(java,开发语言,高并发)