CountDownLatch,CyclicBarrier,Semaphor

最新推荐文章于 2020-11-11 21:34:56 发布
最新推荐文章于 2020-11-11 21:34:56 发布
阅读量110 收藏
点赞数
分类专栏： Java并发编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JingLxian/article/details/107252913
版权

文章目录


参考资料

1 概述
  1. CountDownLatch 和 CyclicBarrier 都能够 实现线程之间的等待 ，只不过它们侧重点不同
  • CountDownLatch 一般用于 某个线程 A等待若干个其他线程执行完任务之后，它才执行
  • CyclicBarrier 一般用于 一组线程 互相等待至某个状态，然后这一组线程再同时执行
  • CountDownLatch 不能重用，CyclicBarrier 可以重用
  1. Semaphore 和 锁 有点类似，它一般用于控制对 某组资源 的访问权限
2 CountDownLatch 用法

利用它可以实现类似计数器的功能，比如有一个任务A，它要等待其他4个任务执行完毕之后才能执行，此时就可以利用 CountDownLatch 来实现这种功能。

CountDownLatch类只提供了一个构造器：

public CountDownLatch(int count) {  };  //参数count为计数值

下面这3个方法是CountDownLatch类中最重要的方法：

public void await() throws InterruptedException { };   //调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { }; //和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
public void countDown() { };  //将count值减1

示例：

public class CountDownLatchTest {

    public static void main(String[] args) {
        final CountDownLatch latch = new CountDownLatch(2);

        new Thread(){
            public void run(){
                try {
                    System.out.println("子线程" + Thread.currentThread().getName() + "正在执行");
                    Thread.sleep(3000);
                    System.out.println("子线程" + Thread.currentThread().getName() + "执行完毕");
                    latch.countDown();
                } catch (InterruptedException e){
                    e.printStackTrace();
                }
            };
        }.start();

        new Thread(){
            public void run(){
                try {
                    System.out.println("子线程" + Thread.currentThread().getName() + "正在执行");
                    Thread.sleep(3000);
                    System.out.println("子线程" + Thread.currentThread().getName() + "执行完毕");
                    latch.countDown();
                } catch (InterruptedException e){
                    e.printStackTrace();
                }
            };
        }.start();

        try{
            System.out.println("等待2个子线程执行完毕...");
            latch.await();
            System.out.println("2个子线程已经执行完毕");
            System.out.println("继续执行主线程");
        }catch (InterruptedException e){
            e.printStackTrace();
        }
  }
}

执行结果：

等待2个子线程执行完毕...
子线程Thread-0正在执行
子线程Thread-1正在执行
子线程Thread-0执行完毕
子线程Thread-1执行完毕
2个子线程已经执行完毕
继续执行主线程
3 CyclicBarrier 用法
  • 通过它可以实现让一组线程等待至某个状态之后再全部同时执行
  • 叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用，我们暂且把这个状态就叫做barrier
  • 当调用await()方法之后，线程就处于barrier了

CyclicBarrier提供2个构造器：

public CyclicBarrier(int parties, Runnable barrierAction) {
}
public CyclicBarrier(int parties) {
}

参数parties指让多少个线程或者任务等待至barrier状态
参数barrierAction为当这些线程都达到barrier状态时会执行的内容

CyclicBarrier中最重要的方法就是await方法，它有2个重载版本:

public int await() throws InterruptedException, BrokenBarrierException { };
public int await(long timeout, TimeUnit unit)throws InterruptedException,BrokenBarrierException,TimeoutException { };

第一个版本比较常用，用来挂起当前线程，直至所有线程都到达barrier状态再同时执行后续任务；
第二个版本是让这些线程等待至一定的时间，如果还有线程没有到达barrier状态就直接让到达barrier的线程执行后续任务

3.1 常规用法

假若有若干个线程都要进行写数据操作，并且只有所有线程都完成写数据操作之后，这些线程才能继续做后面的事情，此时就可以利用CyclicBarrier

public class CyclicBarrierTest {

    public static void main(String[] args) {
        int N = 4;
        CyclicBarrier cyclicBarrier = new CyclicBarrier(N);
        for(int i=0;i<N;i++)
            new Writer(cyclicBarrier).start();
    }
    static class Writer extends Thread {
        private CyclicBarrier cyclicBarrier;
        public Writer(CyclicBarrier cyclicBarrier){
            this.cyclicBarrier = cyclicBarrier;
        }

        public void run(){
            System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据...");
            try{
                Thread.sleep(5000);  //以睡眠来模拟写入数据操作
                System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
                cyclicBarrier.await();
            }catch (InterruptedException e){
                e.printStackTrace();
            }catch (BrokenBarrierException e){
                e.printStackTrace();
            }
            System.out.println("所有线程写入完毕，继续处理其他任务...");
        }

    }
}

执行结果：

线程Thread-0正在写入数据...
线程Thread-2正在写入数据...
线程Thread-1正在写入数据...
线程Thread-3正在写入数据...
线程Thread-3写入数据完毕，等待其他线程写入完毕
线程Thread-2写入数据完毕，等待其他线程写入完毕
线程Thread-1写入数据完毕，等待其他线程写入完毕
线程Thread-0写入数据完毕，等待其他线程写入完毕
所有线程写入完毕，继续处理其他任务...`在这里插入代码片`
所有线程写入完毕，继续处理其他任务...
所有线程写入完毕，继续处理其他任务...
所有线程写入完毕，继续处理其他任务...

从上面输出结果可以看出，每个写入线程执行完写数据操作之后，就在等待其他线程写入操作完毕
当所有线程线程写入操作完毕之后，所有线程就继续进行后续的操作了

3.2 在所有线程写入操作完之后，进行额外的其他操作

为 CyclicBarrier 提供 Runnable参数

public class CyclicBarrierTest {

    public static void main(String[] args) {
        int N = 4;
        CyclicBarrier cyclicBarrier = new CyclicBarrier(N, new Runnable() {
            @Override
            public void run() {
                System.out.println("当前线程"+Thread.currentThread().getName());
            }
        });
        for(int i=0;i<N;i++)
            new Writer(cyclicBarrier).start();
    }
    static class Writer extends Thread {
        private CyclicBarrier cyclicBarrier;
        public Writer(CyclicBarrier cyclicBarrier){
            this.cyclicBarrier = cyclicBarrier;
        }

        public void run(){
            System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据...");
            try{
                Thread.sleep(5000);  //以睡眠来模拟写入数据操作
                System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
                cyclicBarrier.await();
            }catch (InterruptedException e){
                e.printStackTrace();
            }catch (BrokenBarrierException e){
                e.printStackTrace();
            }
            System.out.println("所有线程写入完毕，继续处理其他任务...");
        }

    }
}

执行结果：

线程Thread-0正在写入数据...
线程Thread-3正在写入数据...
线程Thread-2正在写入数据...
线程Thread-1正在写入数据...
线程Thread-2写入数据完毕，等待其他线程写入完毕
线程Thread-1写入数据完毕，等待其他线程写入完毕
线程Thread-3写入数据完毕，等待其他线程写入完毕
线程Thread-0写入数据完毕，等待其他线程写入完毕
当前线程Thread-1
所有线程写入完毕，继续处理其他任务...
所有线程写入完毕，继续处理其他任务...
所有线程写入完毕，继续处理其他任务...
所有线程写入完毕，继续处理其他任务...

从结果可以看出，当四个线程都到达barrier状态后，会从四个线程中选择一个线程去执行Runnable

3.3 为 await() 指定时间的效果
public class CyclicBarrierTest {

    public static void main(String[] args) {
        int N = 4;
        CyclicBarrier cyclicBarrier = new CyclicBarrier(N);

        for(int i=0;i<N;i++){
            if(i < N-1 ){
                new Writer(cyclicBarrier).start();
            } else{
                try{
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                new Writer(cyclicBarrier).start();
            }
        }
    }
    static class Writer extends Thread {
        private CyclicBarrier cyclicBarrier;
        public Writer(CyclicBarrier cyclicBarrier){
            this.cyclicBarrier = cyclicBarrier;
        }

        public void run(){
            System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据...");
            try{
                Thread.sleep(5000);  //以睡眠来模拟写入数据操作
                System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
                try {
                    cyclicBarrier.await(2000, TimeUnit.MILLISECONDS);
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }catch (InterruptedException e){
                e.printStackTrace();
            }catch (BrokenBarrierException e){
                e.printStackTrace();
            }
            System.out.println("所有线程写入完毕，继续处理其他任务...");
        }

    }
}

执行结果

线程Thread-0正在写入数据...
线程Thread-1正在写入数据...
线程Thread-2正在写入数据...
线程Thread-0写入数据完毕，等待其他线程写入完毕
线程Thread-2写入数据完毕，等待其他线程写入完毕
线程Thread-1写入数据完毕，等待其他线程写入完毕
线程Thread-3正在写入数据...
java.util.concurrent.BrokenBarrierException
  at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250)
  at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:435)
  at Construct.CyclicBarrierTest$Writer.run(CyclicBarrierTest.java:39)
 所有线程写入完毕，继续处理其他任务...
 java.util.concurrent.TimeoutException
   at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:257)
   at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:435)
   at Construct.CyclicBarrierTest$Writer.run(CyclicBarrierTest.java:39)
 所有线程写入完毕，继续处理其他任务...java.util.concurrent.BrokenBarrierException  
    at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:250)
    at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:435)
    at Construct.CyclicBarrierTest$Writer.run(CyclicBarrierTest.java:39)
所有线程写入完毕，继续处理其他任务...
线程Thread-3写入数据完毕，等待其他线程写入完毕
java.util.concurrent.BrokenBarrierException
  at java.util.concurrent.CyclicBarrier.dowait(CyclicBarrier.java:207)
  at java.util.concurrent.CyclicBarrier.await(CyclicBarrier.java:435)
  at Construct.CyclicBarrierTest$Writer.run(CyclicBarrierTest.java:39)所有线程写入完毕，继续处理其他任务...

上面的代码在main方法的for循环中，故意让最后一个线程启动延迟，因为在前面三个线程都达到barrier之后，等待了指定的时间发现第四个线程还没有达到barrier，就抛出异常并继续执行后面的任务

3.4 CyclicBarrier 的 重用
public class CyclicBarrierTest {

    public static void main(String[] args) {
        int N = 4;
        CyclicBarrier cyclicBarrier = new CyclicBarrier(N);

        for(int i=0;i<N;i++){
            new Writer(cyclicBarrier).start();
        }

        try{
            Thread.sleep(25000);
        } catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println("CyclicBarrier重用");

        for(int i=0;i<N;i++){
            new Writer(cyclicBarrier).start();
        }

    }
    static class Writer extends Thread {
        private CyclicBarrier cyclicBarrier;
        public Writer(CyclicBarrier cyclicBarrier){
            this.cyclicBarrier = cyclicBarrier;
        }

        public void run(){
            System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据...");
            try{
                Thread.sleep(5000);  //以睡眠来模拟写入数据操作
                System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
                cyclicBarrier.await();
            }catch (InterruptedException e){
                e.printStackTrace();
            }catch (BrokenBarrierException e){
                e.printStackTrace();
            }
            System.out.println("所有线程写入完毕，继续处理其他任务...");
        }

    }
}

执行结果：

线程Thread-1正在写入数据...
线程Thread-3正在写入数据...
线程Thread-2正在写入数据...
线程Thread-0正在写入数据...
线程Thread-3写入数据完毕，等待其他线程写入完毕
线程Thread-0写入数据完毕，等待其他线程写入完毕
线程Thread-2写入数据完毕，等待其他线程写入完毕
线程Thread-1写入数据完毕，等待其他线程写入完毕
所有线程写入完毕，继续处理其他任务...
所有线程写入完毕，继续处理其他任务...
所有线程写入完毕，继续处理其他任务...
所有线程写入完毕，继续处理其他任务...
CyclicBarrier重用
线程Thread-4正在写入数据...
线程Thread-6正在写入数据...
线程Thread-5正在写入数据...
线程Thread-7正在写入数据...
线程Thread-7写入数据完毕，等待其他线程写入完毕
线程Thread-5写入数据完毕，等待其他线程写入完毕
线程Thread-6写入数据完毕，等待其他线程写入完毕
线程Thread-4写入数据完毕，等待其他线程写入完毕
所有线程写入完毕，继续处理其他任务...
所有线程写入完毕，继续处理其他任务...
所有线程写入完毕，继续处理其他任务...
所有线程写入完毕，继续处理其他任务...

从执行结果可以看出，在初次的4个线程越过barrier状态后，又可以用来进行新一轮的使用

4 Semaphore 的 用法

Semaphore 可以控制 同时访问的线程个数 ，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可
Semaphore 提供了2个构造器：

public Semaphore(int permits) {    //参数permits表示许可数目，即同时可以允许多少线程进行访问
   sync = new NonfairSync(permits);
}
public Semaphore(int permits, boolean fair) { //这个多了一个参数fair表示是否是公平的，即等待时间越久的越先获取许可
  sync = (fair)? new FairSync(permits) : new NonfairSync(permits);  
}

Semaphore类中比较重要的几个方法，首先是acquire()、release()方法：

public void acquire() throws InterruptedException {  }     //获取一个许可
public void acquire(int permits) throws InterruptedException { }    //获取permits个许可
public void release() { }          //释放一个许可
public void release(int permits) { }    //释放permits个许可
  • acquire()用来获取一个许可，若无许可能够获得，则会一直等待，直到获得许可
  • release()用来释放许可。注意，在释放许可之前，必须先获获得许可

这4个方法都会被阻塞，如果想立即得到执行结果，可以使用下面几个方法：

public boolean tryAcquire() { };   //尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException { }; //尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false
public boolean tryAcquire(int permits) { }; //尝试获取permits个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException { }; //尝试获取permits个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false

另外还可以通过 availablePermits() 方法得到 可用的许可数目。

示例：

假若一个工厂有5台机器，但是有8个工人，一台机器同时只能被一个工人使用，只有使用完了，其他工人才能继续使用

public class SemaphoreTest {

    public static void main(String[] args) {
        int N = 8;
        Semaphore semaphore = new Semaphore(5);
        for(int i =0; i<N; i++)
            new Worker(i,semaphore).start();
    }

    static class Worker extends Thread{
        private int num;
        private Semaphore semaphore;
        public Worker(int num,Semaphore semaphore){
            this.num = num;
            this.semaphore = semaphore;
        }

        public void run(){
            try {
                semaphore.acquire();
                System.out.println("工人"+this.num+"占用一个机器在生产...");
                Thread.sleep(2000);
                System.out.println("工人"+this.num+"释放出机器");
                semaphore.release();
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

执行结果：

工人0占用一个机器在生产...
工人1占用一个机器在生产...
工人2占用一个机器在生产...
工人3占用一个机器在生产...
工人4占用一个机器在生产...
工人4释放出机器
工人0释放出机器
工人2释放出机器
工人1释放出机器
工人5占用一个机器在生产...
工人3释放出机器
工人7占用一个机器在生产...
工人6占用一个机器在生产...
工人7释放出机器
工人5释放出机器
工人6释放出机器
ly_dsjing
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CountDownLatch、Semaphore和CyclicBarrier区别
wy971744839的博客
04-05 290
Java并发包中有三个类用于同步一批线程的行为，分别是CountDownLatch、Semaphore和CyclicBarrier。
多线程之并发类CountDownLatch、CyclicBarrier和Semaphor的使用
qq_37212210的博客
04-21 334
CountDownLatch 并发类CountDownLatch是什么？ CountDownLatch：一个或多个线程等待其他线程完成操作。 什么情况下使用？ 某一个动作需要等待其它线程完成后才会触发。 举个栗子，一个班上50个人，考完试之后需要计算全班同学的总成绩，这种情况使用CountDownLatch并发类就最合适了，每一个人的成绩等于一个线程，需要等待50个线程执行完之后才能执行最后...
AQS 源码解析 - 结合ReentrantLock，ReentrantReadWriteLock，CountDownLatch，CyclicBarrier，Semaphor
秋夫人
11-11 445
JDK1.5以前只有synchronized同步锁，并且效率非常低，因此大神Doug Lea自己写了一套并发框架，这套框架的核心就在于AbstractQueuedSynchronizer类（即AQS），性能非常高，所以被引入JDK包中，即JUC。 那么AQS是怎么实现的呢？ 本篇就是对AQS及其相关组件进行分析，了解其原理，并领略大神的优美而又精简的代码。 AbstractQueuedSynchronizer AQS是JUC下最核心的类，没有之一，所以我们先来分析一下这个类的数据结构。 AbstractQ
JUC之CountDownLatch&CyclicBarrier&Semaphore
rekingman的博客
08-09 284
CountDownLatch&CyclicBarrier&Semaphor 文章目录CountDownLatch&CyclicBarrier&Semaphor引言一、CountDownLatch1、使用2、实现原理二、CyclicBarrier概念1、使用2、实现原理三、Semaphor1、应用场景2、使用3、实现原理总结 引言 ​ CountDownLatch&a...
JAVA线程并发工具类笔记整理Fork-Join、CountDownLatch、CyclicBarrier、Semaphore、Exchange、Callable、FutureTask
weixin_43838446的博客
04-23 283
1. Fork-Join 什么是分而治之？ 规模为N的问题，N<阈值，直接解决，N>阈值，将N分解为K个小规模子问题，子问题互相对立，与原问题形式相同，将子问题的解合并得到原问题的解。分而治之思想应用：在快速排序、归并排序、动态规划等等。 工作密取（workStealing）：线程A完成了工作之后可以被调度去帮线程B完成task，为了避免竞争获取任务，从相反的方向获取任务。 For...
多线程（8）-同步辅助类CountDownLatch&CyclicBarrier& Semaphor
weixin_33777877的博客
07-28 53
2019独角兽企业重金招聘Python工程师标准>>> ...
java之并发工具类屏障（CyclicBarrier ）以及CountDownLatch 、Semaphore之间区别
感冒石头的博客
12-29 503
1、CountDownLatch ：能够使一个或多个线程等待其他线程完成各自的工作后再执行2、CyclicBarrier ： 让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。3、Semaphore ： 用来控制同时访问特定资源的线程数量，它通过协调各个线程，以保证合理地使用公共资源4、Exchanger： 用于线程间...
CountDownLatch、CyclicBarrier和 Semaphore 使用方法和使用场景
烂笔头-D的专栏
05-07 630
CountDownLatch 计数器构造方法：public CountDownLatch(int count) {  };  //参数count为计数值方法：public void await() throws InterruptedException { };   //调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行public boolean await(long ...
Java并发之Semaphor、以及与CountDownlatch和CyclicBarrier区别
m0_50334429的博客
08-25 114
一、Semaphor作用 控制并发线程数 用于多个共享资源互斥使用。【也就是具有锁的功能】 二、应用场景 用于做流量控制，特别公用资源有限的应用场景，比如数据库连接 三、重要方法 1、semaphore.acquire(); 请求一个信号量，这时候信号量个数-1，当减少到0的时候，下一次acquire不会再执行，只有当执行一个release()的时候，信号量不为0的时候才可以继续执行acquire 2、semaphore.release(); 释放一个信号量，这时候信号量个数+1，
详解java CountDownLatch和CyclicBarrier在内部实现和场景上的区别
08-19
在Java并发编程中，CountDownLatch和CyclicBarrier都是用于协调多线程间同步的重要工具，它们可以帮助开发者在特定条件满足时启动或者结束线程的执行。本文将详细探讨这两个类的内部实现机制以及它们在实际应用场景...
CountDownLatch和CyclicBarrier用法实例大全
06-08
在Java并发编程中，CountDownLatch和CyclicBarrier是两种非常重要的同步工具类，它们用于协调多个线程间的协作。这两个工具都是在`java.util.concurrent`包下，是Java并发库的重要组成部分。 **CountDownLatch** ...
Java并发编程：CountDownLatch与CyclicBarrier和Semaphore的实例详解
08-29
Java并发编程：CountDownLatch与CyclicBarrier和Semaphore的实例详解 Java并发编程是Java语言中的一种高级技术，用于处理多线程编程中的同步问题。Java 1.5中引入了几个高效的辅助类，包括CountDownLatch、...
CountDownLatch、CyclicBarrier、Semaphore.md
06-07
java 高并发应用场景
java并发编程中CountDownLatch和CyclicBarrier的使用借鉴.pdf
11-28
java并发编程中CountDownLatch和CyclicBarrier的使用借鉴 java并发编程中CountDownLatch和CyclicBarrier是两个非常重要的线程控制和调度工具，经常被用于解决多线程程序设计中的线程等待问题。本文将对...
Lock锁的方法使用
ly_jing的博客
07-06 3029
文章目录1 Lock1.1 lock() 方法1.2 tryLock()方法与 tryLock(long time, TimeUnit unit)方法1.3 lockInterruptibly() 方法2 ReentrantLock2.1 lock() 的 正确使用方法2.2 tryLock()的使用方法2.3 lockInterruptibly() 响应中断的使用方法3 ReadWriteLock4 ReentrantReadWriteLock 1 Lock 通过查看 Lock 的源码可知
Thread类的使用
ly_jing的博客
06-30 754
文章目录1 线程的状态2 上下文切换3 Thread类中的常用方法3.1 start() 方法3.2 run() 方法3.3 sleep() 方法3.4 yield() 方法3.5 join() 方法3.6 interrupt() 方法3.7 stop()方法 destroy()方法3.8 有关线程属性的几个方法4 Thread类中方法的调用对线程状态变化的影响 1 线程的状态 线程的状态包括： 创建(new) 就绪(runnable) 运行(running) 阻塞(blocked , time w
线程的创建和多线程
ly_jing的博客
06-30 585
文章目录1 Java中关于应用程序和进程相关的概念2 线程的特点3 线程的创建3.1 继承Thread类创建线程类3.2 实现 Runnable接口3.3 两种继承方式的区别4 多线程有几种实现同步方法 ？5 产生死锁的原因6 避免死锁 1 Java中关于应用程序和进程相关的概念 在Java中，一个应用程序对应着一个JVM实例（也有地方称为JVM进程），一般来说名字默认为java.exe或者javaw.exe（windows下可以通过任务管理器查看）。 Java采用的是 单线程编程模型，即在 我们自己的程序
线程间协作的两种方式
ly_jing的博客
07-13 423
文章目录1 wait()，notify()，notifyAll2 Condition3 生产者-消费者模型的实现3.1 使用Object的wait()和notify()实现3.2 使用 Condition 实现 参考资料 线程间互相通信的过程，就是线程间的协作 Java中，线程协作的两种常见方式： Object.wait()，Object.notify() Condition 1 wait()，notify()，notifyAll wait()，notify()，notifyAll() 是 Object
CountDownLatch CyclicBarrier
最新发布
08-30
与 CountDownLatch 相比，CyclicBarrier 的主要区别在于它可以重复使用，而且所有线程必须同时到达栅栏处才能继续执行后续任务。CyclicBarrier 的重要方法是 await()，并且可以通过构造方法传入一个 Runnable，在...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值