【Semaphore、ReentrantLock、CountDownLatch、Cyclicbarrier、ReadWriteLock】多线程交替执行、顺序执行、同时执行、读写分离执行、生产者消费者

最新推荐文章于 2024-07-23 23:22:18 发布
最新推荐文章于 2024-07-23 23:22:18 发布
阅读量386 收藏 3
点赞数
分类专栏： Java 面试 文章标签： 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wyn_365/article/details/120991785
版权
Java 同时被 2 个专栏收录
119 篇文章 4 订阅
订阅专栏
面试
73 篇文章 8 订阅
订阅专栏

一、交替执行

建立3个线程，完成交替执行，按照123123123…打印

1.1 使用Lock的ReentrantLock实现

public class ThreadPrint {
    public static void main(String[] args) {
        Print123 print123 = new Print123();
        new Thread(()->{
           while (true){
               print123.print1();
           }
        }).start();

        new Thread(()->{
            while (true){
                print123.print2();
            }
        }).start();

        new Thread(()->{
            while (true){
                print123.print3();
            }
        }).start();
    }

}

// 线程资源类
class Print123{
    private int number = 1;
    private Lock lock = new ReentrantLock();
    private Condition con1 = lock.newCondition();
    private Condition con2 = lock.newCondition();
    private Condition con3 = lock.newCondition();

    public void print1(){
        lock.lock();
        try{
            if (number!=1){
                con1.await();
            }
            System.out.println(1);
            Thread.sleep(1000);
            number = 2;
            con2.signal();
        }catch (Exception e){
            System.out.println("1发生异常！");
        }finally {
            lock.unlock();
        }
    }

    public void print2(){
        lock.lock();
        try{
            if (number!=2){
                con2.await();
            }
            System.out.println(2);
            Thread.sleep(1000);
            number = 3;
            con3.signal();
        }catch (Exception e){
            System.out.println("2发生异常！");
        }finally {
            lock.unlock();
        }
    }

    public void print3(){
        lock.lock();
        try{
            if (number!=3){
                con3.await();
            }
            System.out.println(3);
            Thread.sleep(1000);
            number = 1;
            con1.signal();
        }catch (Exception e){
            System.out.println("3发生异常！");
        }finally {
            lock.unlock();
        }
    }
}

在这里插入图片描述

1.2 使用Semaphore交替执行1

每次个线程执行时，先获取唯一的许可，继而打印自己的value值；之后再将许可释放给下一个信号量，让下一个信号量打印value……

public class Print123WithSemaphore {
    public static void main(String[] args) {
        Print123With pring = new Print123With();
        new Thread(() -> pring.print1()).start();
        new Thread(() -> pring.pring2()).start();
        new Thread(() -> pring.print3()).start();
    }
}

class Print123With {
    //定义三个信号量，并且这三个信号量一共只有1个许可证
    private Semaphore semaphore1 = new Semaphore(1);
    private Semaphore semaphore2 = new Semaphore(0);
    private Semaphore semaphore3 = new Semaphore(0);

    public void print1() {
        print("1", semaphore1, semaphore2);
    }
    public void pring2() {
        print("2", semaphore2, semaphore3);
    }
    public void print3() {
        print("3", semaphore3, semaphore1);
    }

    /*
        value：打印的字符
        currentSemaphore：当前信号量
        nextSemaphore：下一个信号量
     */
    private void print(String value, Semaphore currentSemaphore, Semaphore nextSemaphore) {
        for (int i = 0; i < 10; ) {
            try {
                currentSemaphore.acquire();
                System.out.println(Thread.currentThread().getName() +" print "+ value);
                Thread.sleep(1000);
                i++;
                nextSemaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

在这里插入图片描述

1.3 Semaphore交替执行2

public class SemaphorePrint {
    private static Semaphore s1 = new Semaphore(1);
    private static Semaphore s2 = new Semaphore(0);
    private static Semaphore s3 = new Semaphore(0);

    public static void main(String[] args) {



        new Thread(()->{
            while (true){
                try{
                    s1.acquire();
                    System.out.println("A");
                    Thread.sleep(1000);
                }catch (Exception e){
                    System.out.println("异常");
                }finally {
                    s2.release();
                }
            }
        }).start();


        new Thread(()->{
            while (true){
                try{
                    s2.acquire();
                    System.out.println("B");
                    Thread.sleep(1000);
                }catch (Exception e){
                    System.out.println("异常");
                }finally {
                    s3.release();
                }
            }
        }).start();


        new Thread(()->{
            while (true){
                try{
                    s3.acquire();
                    System.out.println("C");
                    Thread.sleep(1000);
                }catch (Exception e){
                    System.out.println("异常");
                }finally {
                    s1.release();
                }
            }
        }).start();
    }
}

在这里插入图片描述

二、同时并发执行

2.1 Semaphore实现

默认所有的线程都是阻塞的，调用semaphore构造方法，设置线程的并发数，然后通过acquire()方法允许同一时间只能有三个线程来执行，三个线程执行完毕后，就可以调用release()来释放一次可执行的机会，然后从其他的线程里面随机挑选一个来执行。

public class SemaphoreWithBingfa {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        // 同一时间，只允许3个线程并发访问
        Semaphore semp = new Semaphore(3);
        // 创建10个线程
        for (int i = 0; i < 8; i++) {
            final int threadNo = i;
            //execute()方法的参数：重写了run()方法的Runnable对象
            executor.execute(() -> {
                        try {
                            //同一时间，只能有3个线程获取许可去执行
                            semp.acquire();
                            System.out.println("得到许可并执行的线程: " + threadNo);
                            Thread.sleep(1000);
                            // 得到许可的线程执行完毕后，将许可转让给其他线程
                            semp.release();
                        } catch (InterruptedException e) {
                        }
                    }
            );
        }
        //  executor.shutdown();
    }
}

在这里插入图片描述

2.2 CyclicBarrier实现状态同时执行

使用这个CyclicBarrier，可以实现A,B,C全部就绪后，await()表示就绪，然后三者开始同时执行。
例如：当三个人的会议，必须等到三个人到齐后，再能开始进行执行开始。

public class CyclicBarrierTest {
    public static void main(String[] args) {
        ExecutorService executor = Executors.newCachedThreadPool();
        //等待3个人全部到齐 才能开会
        CyclicBarrier barrier = new CyclicBarrier(3);

        for (int i = 0; i < 3; i++) {
            //设置人员的编号
            final int person = i;
            executor.execute(() -> {
                try {
                    System.out.println(Thread.currentThread().getName() + "用户" + person + "到达会议室了。");
                    barrier.await();

                    //3个人都到达  线程全部开始执行
                    System.out.println("三个人到齐，" + Thread.currentThread().getName() + "开始开会干活！！！");

                } catch (Exception e) {
                }
            });
        }
        executor.shutdown();
    }

}

在这里插入图片描述

2.3 CountDownLatch 实现倒数计时【闭锁】

主要用于确保，某个计算，某个任务，某个服务线程，等到以来的所有线程执行完毕后，再去执行。
例如：等所有人走后，班长再走去关灯。

public class CountDownLatchTest {
    public static void main(String[] args) {
        CountDownLatch countDownLatch = new CountDownLatch(10);
        for (int i = 0; i < 10; i++) {
            new Thread(()->{
                try{
                    System.out.println(Thread.currentThread().getName()+"正在执行...");
                }catch (Exception e){
                }finally {
                    countDownLatch.countDown();
                }
            }).start();
        }
        try{
            countDownLatch.await();
        }catch (Exception e){
        }
        System.out.println("主线程执行...");
    }
}

在这里插入图片描述

三、ReadWriteLock读写锁实现

为了更好地解决多线程读写带来的并发问题，JUC提供了ReadWriteLock，分别为读和写进行加锁的操作。
例如：
t1线程获取读锁，t2也可以获取读锁中的内容
如果t1线程获得了写锁，其他线程不能申请写锁或者读锁，必须等待t1释放锁资源。
这一点有些像mysql中的X锁与S锁，排他锁与共享锁。

3.1 ReentrantReadWriteLock 实现读写分离

public class ReadWriteLockTest {
    private static ReentrantReadWriteLock readwrite = new ReentrantReadWriteLock();

    public static void main(String[] args) {
        // 1.开启两个线程【同时进行读和写】
        new Thread(()->{
            myRead(Thread.currentThread());
            mtWrite(Thread.currentThread());
        },"t1").start();

        new Thread(()->{
            myRead(Thread.currentThread());
            mtWrite(Thread.currentThread());
        },"t2").start();

    }

    // 1.读锁来锁定操作
    static void myRead(Thread thread){
        readwrite.readLock().lock();
        try{
            for (int i = 0; i < 10000; i++) {
                System.out.println(thread.getName()+"正在进行读操作");
            }
            System.out.println(thread.getName()+"读操作完成");
        }finally {
            readwrite.readLock().unlock();
        }
    }

    // 2.写操作来进行锁定
    static void mtWrite(Thread thread){
        readwrite.writeLock().lock();
        try{
            for (int i = 0; i < 10000; i++) {
                System.out.println(thread.getName()+"正在进行写操作");
            }
            System.out.println(thread.getName()+"写操作完成");
        }finally {
            readwrite.writeLock().unlock();
        }
    }
}

在这里插入图片描述
在这里插入图片描述

3.2 CopyOnWrite 读写分离并发容器

同步容器 ：Hashtable/Vector/Stack,早期设计中，并没有考虑并发的问题，因此在多出线程的情况下，是会出现ConcurrentModificationException异常的。
除了ConcurrnetHashMap,CopyOnWriteArrayList之外，JUC还提供了CopyOnWriteArraySet，ConcurrentLinkedQueue,PriorityBlockingQueue等并发容器类。
当向一个CopyOnWrite 容器中增加元素的时候，就会将容器复制一份。如：
1.容器复制一份，然后新的容器添加元素
2.增加元素后，在将引用指向新的容器，原容器被GC回收
CopyOnWrite 利用冗余实现了读写分离，适合用于【读多写少】的场景，复制比较消耗性能

四、生产者消费者

文中采用加锁的方式来实现生产者和消费者，如synchronized和Lock，
也可以【共享缓冲区】采用阻塞队列来实现BlockingQueue来实现，设置一个固定大小的缓冲区，达到最大值则无法生产，生产者进行阻塞，知道消费者消费后，小于阻塞队列的大小，则开始进行生产。

4.1 Synchronized来实现

//测试方法
public class ProducerWithConsumerWithSynchronized {
    public static void main(String[] args) {
        // 生产者和消费者共用同一个Car对象
        Car car = new Car();
        Producer pro = new Producer(car);
        Consumer con = new Consumer(car);
        //2个生产者 2个消费者
        Thread pro1 = new Thread(pro);
        Thread pro2 = new Thread(pro);
        Thread con1 = new Thread(con);
        Thread con2 = new Thread(con);
        pro1.start();
        pro2.start();
        con1.start();
        con2.start();
    }
}

// 汽车资源类
class Car{
    int cars;
    // 生产汽车的方法
    public synchronized void productCar(){
        try{
            if (cars<20){
                System.out.println("生产汽车："+cars);
                cars++;
                notifyAll();
            }else {
                wait();
            }
        }catch (Exception e){}
    }

    // 消费汽车的方法
    public synchronized void consumeCar(){
        try{
            if (cars>0){
                System.out.println("销售汽车："+cars);
                cars--;
                notifyAll();
            }else {
                wait();
            }
        }catch (Exception e){}
    }
}

//生产者
class Producer implements Runnable{
    Car car;
    public Producer(Car car) {
        this.car = car;
    }

    @Override
    public void run() {
        while (true){
            car.productCar();
        }
    }
}

// 消费者
class Consumer implements Runnable{
    Car car;
    public Consumer(Car car) {
        this.car = car;
    }

    @Override
    public void run() {
        while (true){
            car.consumeCar();
        }
    }
}

在这里插入图片描述

4.2 Lock的ReentrantLock实现

class Cars{
    int cars;
    private Lock lock = new ReentrantLock();
    private Condition condition = lock.newCondition();

    //生产车
    public void productCar(){
        lock.lock();
        try{
            if (cars<20){
                System.out.println("生产车："+cars);
                cars++;
                condition.signalAll();
            }else {
                condition.await();
            }
        }catch (Exception e){
        }finally {
            lock.unlock();
        }
    }
    // 消费车
    public void consumeCar(){
        lock.lock();
        try{
            if (cars>0){
                System.out.println("消费车："+cars);
                cars--;
                condition.signalAll();
            }else {
                condition.await();
            }
        }catch (Exception e){
        }finally {
            lock.unlock();
        }
    }
}
多线程/并发编程——同步工具类(CountDownLatch、Semaphore、ReadWriteLock、CyclicBarrier )
qq_42583242的博客
10-04 578
多线程/并发编程——同步工具类 文章目录多线程/并发编程——同步工具类一、CountDownLatch二、Semaphore三、ReadWriteLock四、CyclicBarrier 上一篇文章中，我们详细剖析了并发工具包 J.U.C 的底层实现 AQS 的细节，不过只解释了基于 AQS 的最常用的同步工具锁 ReentrantLock。诚然 ReentrantLock 是很常用、很重要的一个同步工具类。不过基于 AQS 其实还有很多同步工具类，下面我们就来学习一下这些同步工具类的简单实用 本篇文章中只
CountDownLatch、CyclicBarrier、 Semaphore、ReentrantLock和AQS
qq_36523667的博客
07-15 477
学习自http://www.importnew.com/21889.htmlhttps://blog.csdn.net/yanyan19880509/article/details/52349056https://www.cnblogs.com/waterystone/p/4920797.html123public void await() throws InterruptedException ...
JUC类（ReentrantLock、Semaphore、CountDownLatch、CyclicBarrier）
m0_48273471的博客
04-18 751
java.util.concurrent 下的类就叫 JUC 类，JUC 下典型的类有： ● ReentrantLock ● Semaphore ● CountDownLatch ● CyclicBarrier 1. ReentrantLock：可重⼊锁 public class ThreadDemo22 { public static void main(String[] arg...
java实现管程之AQS以及ReentrantLock、Semaphore、CountDownLatch、CyclicBarrier
weixin_36279234的博客
12-31 788
管程 管程是管理共享变量和对共享变量操作的过程；上文讲解了synchronized在jvm层面实现了MESA管程模型，本文阐述AQS在java层面实现MESA管程模型 AQS--AbstractQueuedSynchronizer AQS是java层面实现管程的同步队列抽象类，抽象类实现管程的同步等待队列和条件等待队列；而加锁和解锁的逻辑由具体的子类实现，只是对外提供模板方法，由程序员自己实现加解锁的逻辑。 AQS特性 阻塞等待队列；共享/独占；公平/非公平；可重入；可中断...
AQS梳理【ReentrantLock|CountDownLatch|Semaphore|CyclicBarrier|ReentrantReadWriteLock】
u013657993的专栏
07-29 501
概述 aqs是java并发包的一个基石级别服务，主要是通过队列和大量的cas来玩转。本文我们会基于公平锁来跟进 抢锁流程 后续补个图，这个是公平锁的lock方法。ReentraLock的内部类 FairSync 类关系 FairSync extend Sync（抽象类） extends AbstractQueuedSynchronizer sync定义了lock抽象方法给 子类实现，FairSync的实现具体是依赖 aqs的 acquire 来看下acquire方法【这是个小模版方法，具.
高并发之ReentrantLock、CountDownLatch、CyclicBarrier（一）
m0_67788957的博客
03-28 363
本系列研究总结高并发下的几种同步锁的使用以及之间的区别,分别是:ReentrantLock、CountDownLatch、CyclicBarrier、Phaser、ReadWriteLock、StampedLock、Semaphore、Exchanger、LockSupport。由于博客园对博客字数的要求限制,会分为三个篇幅: ReentrantLock ReentrantLock重入锁，是实现Lock接口的一个类，也是在实际编程中使用频率很高的一个锁，支持重入性，表示能够对共享资源能够重复加锁，即当前
并发与多线程(二) ReentrantLock/ReadWriteLock/CountDownLatch/CyclicBarrier
最新发布
m0_64643342的博客
07-23 660
包含了JAVA中并发和多线程相关的核心类.
Java多线程编程详解：并发执行与线程通信
如synchronized关键字、volatile变量、Lock接口（ReentrantLock、ReadWriteLock等）以及并发工具类（如Semaphore、CyclicBarrier、CountDownLatch等），这些工具可以帮助我们管理和协调并发执行的线程，确保程序的...
JAVA多线程与高并发(三)[ReentrantLock,ReadWriteLock,CountdownLatch,CyclicBarrier,Phaser,Semaphore,Exchanger]
书院二层楼
03-03 657
link-JAVA多线程与高并发系列[前言,大纲,目录] 前言 这节只讲这些锁的使用,下节讲底层原理(AQS). 如果用了很多锁后,担心死锁逻辑,可以用jstack检查 ReentrantLock和Synchronized相比,最大的特点就是可以根据业务需求灵活控制. ReentrantReadWriteLock用于一块资源读多写少,又要求避免脏数据的情况 Semaphore用于限流,...
详解java多线程的同步控制
01-20
目录线程安全 Thread Safety重入锁 ReentrantLock读写锁 ReadWriteLock倒计数器 CountDownLatch循环栅栏 CyclicBarrier信号量 Semaphore 线程安全 Thread Safety JMM JMM(Java Memory Model)是一种基于计算机内存...
java多线程并发基础(三，ReentrantLock，CountDownLatch，CyclicBarrier，Semaphore实现原理)
Suarge的博客
05-01 848
一、独占锁ReentrantLock的原理 ReentrantLock是可重入的独占锁，同时只能有一个线程可以获取该锁，其他获取该锁的线程会被阻塞放入该锁的AQS阻塞队列里面。 从图中可以看出，ReentrantLock最终还是使用AQS来实现的，并且根据参数来决定其内部是一个公平锁还是非公平锁 public ReentrantLock() { //默认非公平锁 ...
java 并发类semaphore countdownlatch cyclicbarrier reentrantlock condition reentrantreadwritelock
乾坤刀的博客
02-18 450
semaphore      它是基于计数的信号量，初始时设置阈值。在并发情况下，当前线程首先需要获取许可信号，如果在阈值内则可成功获取，否则阻塞等待；对于获取许可信息的线程，最后必须归还。   代码如下：              Semaphore semp = new Semaphore(5); //设置阈值为5        semp.acquire(); // 申请许可
信号量Semaphore,读写锁ReadWriteLock,计数器CountDownLatch,循环栅栏CyclicBarrier运用
欣淡定的博客
01-06 501
1.信号量Semaphore: 像synchronized, ReentrantLock等这些对临界区资源进行同步后,所有对临界区资源进行访问的线程都得串行排队,而信号量允许指定的线程数同时进行访问 demo: import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; import ...
并发—Semaphore、CountDownLatch、CyclicBarrier的使用
季秀的博客
02-01 505
文章目录SemaphoreSemaphore使用，模拟公交车CountDownLatchCountDownLatch 的三种典型用法CountDownLatch 应用，喝到茶要干什么CountDownLatch 应用2，发令枪CyclicBarrierCyclicBarrier应用，游戏中多个玩家同时进入游戏CyclicBarrier 应用，模拟秒杀： Semaphore 和 synchroniz...
【多线程高并发】3、多线程synchronized+ReentrantLock+CountDownLatch+CyclicBarrier+MarriagePhaser+Semaphore 等锁【草稿】
zw764987243的博客
11-20 402
**** join（）方法：相当于把t1加入到当前线程，并且等t1执行完再开始t2. yield（）方法：yield可以直接用Thread类调用，yield让出CPU执行权给同等级的线程，进入就绪状态，如果没有相同级别的线程在等待CPU的执行权，则该线程继续执行。 wait（）方法：只能使用在被synchronized修饰的Critical Section（同步方法或同步代码块）中。当线程执行到该方法，线程失去锁，到阻塞态。 sleep（）和sleep（time）方法：由当前线程调用。调用时，线程.
JAVA多线程并发（六）-- ReentrantLock、Semaphore、CountDownLatch 简介
dazhong2012的专栏
05-17 777
ReentrantLock支持公平锁和非公平锁。公平锁会按照线程请求锁的顺序来分配锁，而非公平锁则可能允许刚刚释放锁的线程再次获得锁。默认情况下，ReentrantLock创建的是非公平锁。加锁过程涉及到线程的等待队列和状态变更，而非公平锁和公平锁在加锁时的主要区别在于线程获取锁的顺序。解锁过程则相对简单，主要是将当前线程从锁的持有者中移除，并唤醒等待队列中的其他线程。在Spring应用中，我们可以使用ReentrantLock来实现对共享资源的线程安全访问。
多线程下实现精确控制（lock、CountDownLatch、CyclicBarrier、Semaphore、ReadWriteLock）
weixin_51681634的博客
11-23 274
用 lock相较于 synchronized优点在于：可以用condition 实现对锁的精确控制 每个condition对象相当于一把锁，可以准确阻塞/ 唤醒特定线程 资源类 public class Number { int num = 1; ReentrantLock lock = new ReentrantLock(); Condition conditionA = lock.newCondition(); Condition conditionB = lock.newCondition(); .
006-多线程-基础-同步解决 概述【ReentrantLock、Semaphore、CyclicBarrier、CountDownLatch】...
dilv4062的博客
09-26 180
一、解决方案 004-线程同步问题引出、同步问题解决、死锁、生产者与消费者 通过以上文章可知，通过原子性AtomicLong、以及内部锁(synchronized)机制可以解决线程安全问题。以下是一些高级用法。 1、回顾synchronized： 　　核心类库包含一个 Thread 类，可以用它来构建、启动和操纵线程，Java 语言包括了跨线程传达并发性约束的构造 。 　　...
JUC之各种锁的使用：CountDownLatch，CyclicBarrier，ReadWriteLock，Semaphore
define_us的专栏
06-26 411
CountDownLatch CountDownLatch的典型使用环境是：确保某个操作在其需要的一个多线程操作完成后执行。比如说赛跑者必须等发令枪响。await是阻塞，countDown是倒计，构造函数中指定初始值。只有初始值被countDown到0时，阻塞才会被打开。 //所有线程阻塞，然后统一开始 CountDownLatch begin = new...
JUC三大辅助类（CountDownLatch、CyclicBarrier和Semaphore）、ReadWriteLock（读写锁）和BlockingQueue（阻塞队列）
DengShengL的博客
05-06 458
JUC三大辅助类（CountDownLatch、CyclicBarrier和Semaphore）、ReadWriteLock（读写锁）和BlockingQueue（阻塞队列） CountDownLatch：减少计数方法 作用：让一些线程阻塞直到另一些线程完成一系列操作后才被唤醒。 提供的三个方法： new CountDownLatch(6);设置计数器为6个线程 countDown();将计数器...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Coding路人王

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值