Concurrent - CyclicBarrier

最新推荐文章于 2021-11-13 15:35:44 发布
最新推荐文章于 2021-11-13 15:35:44 发布
阅读量81 收藏
点赞数
分类专栏： Concurrent 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/agileforce/article/details/88300756
版权

原创转载请注明出处：http://agilestyle.iteye.com/blog/2343979

 

CyclicBarrier

CyclicBarrier允许一组线程互相等待，直到到达某个公共屏障点（common barrier point），这些线程必须实时地互相等待，这种情况下就可以使用CyclicBarrier来方便地实现这样的功能。另外，CyclicBarrier的公共屏障点可以重用。

CyclicBarrierTest1.java

package org.fool.java.concurrent.cyclicbarrier;

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

public class CyclicBarrierTest1 {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(5, () -> System.out.println("All invoked!!!"));

        for (int i = 0; i < 5; i++) {
            Thread thread = new Thread(new MyThread(cyclicBarrier));
            thread.start();
        }
    }

    public static class MyThread implements Runnable {

        private CyclicBarrier cyclicBarrier;

        public MyThread(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            try {
                Thread.sleep((int) (Math.random() * 10000));

                System.out.println(Thread.currentThread().getName() + " invoked..." + System.currentTimeMillis());

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

Note:

CyclicBarrier cyclicBarrier = new CyclicBarrier(5, () -> System.out.println("All invoked!!!"));

设置最大为5个parties同行者，也就是5个线程都执行了await()方法后程序才可以继续向下运行，否则这些线程彼此互相等待，一直呈阻塞状态。

 

线程个数大于parties数量进行分批处理

CyclicBarrierTest2.java

package org.fool.java.concurrent.cyclicbarrier;

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

public class CyclicBarrierTest2 {
    public static void main(String[] args) {
        try {
            CyclicBarrier cyclicBarrier = new CyclicBarrier(2, () -> System.out.println("All invoked!!!"));

            for (int i = 0; i < 4; i++) {
                Thread thread = new Thread(new MyThread(cyclicBarrier));
                thread.start();
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static class MyThread implements Runnable {

        private CyclicBarrier cyclicBarrier;

        public MyThread(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            try {
                System.out.println(Thread.currentThread().getName() + " begin=" + System.currentTimeMillis() + " wait 2 threads to continue");

                cyclicBarrier.await();

                System.out.println(Thread.currentThread().getName() + " end=" + System.currentTimeMillis() + " have 2 threads to continue");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }
}
Run 

Note:

从运行结果来看，每出现2个线程就开始RUN

 

getNumberWaiting()

getNumberWaiting()作用是获得有几个线程已经到达屏障点。

CyclicBarrierTest3.java

package org.fool.java.concurrent.cyclicbarrier;

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

public class CyclicBarrierTest3 {
    public static void main(String[] args) {
        try {
            CyclicBarrier cyclicBarrier = new CyclicBarrier(3);

            for (int i = 0; i < 10; i++) {
                Thread thread = new Thread(new MyThread(cyclicBarrier));
                thread.start();
                Thread.sleep(1000);
                System.out.println(cyclicBarrier.getNumberWaiting());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static class MyThread implements Runnable {

        private CyclicBarrier cyclicBarrier;

        public MyThread(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            try {
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }
}

Run


Note:

从运行结果来看，CyclicBarrier具有屏障重置性，也就是parties的值可以重置为0

 

使用CyclicBarrier屏障重置性实现多阶段的比赛实验

CyclicBarrierTest4.java

package org.fool.java.concurrent.cyclicbarrier;

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

public class CyclicBarrierTest4 {
    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(2);

        Service service = new Service(cyclicBarrier);

        for (int i = 0; i < 4; i++) {
            Thread thread = new Thread(new MyThread(service));
            thread.setName("Thread " + (i + 1));
            thread.start();
        }

    }

    public static class Service {
        private CyclicBarrier cyclicBarrier;

        public Service(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }

        public void beginRun() {
            try {
                Thread.sleep((int) (Math.random() * 10000));

                System.out.println(Thread.currentThread().getName() + " "
                        + System.currentTimeMillis() + " begin No.1 phase "
                        + (cyclicBarrier.getNumberWaiting() + 1));

                cyclicBarrier.await();

                System.out.println(Thread.currentThread().getName() + " "
                        + System.currentTimeMillis() + " end No.1 phase "
                        + (cyclicBarrier.getNumberWaiting()));

                Thread.sleep((int) (Math.random() * 10000));

                System.out.println(Thread.currentThread().getName() + " "
                        + System.currentTimeMillis() + " begin No.2 phase "
                        + (cyclicBarrier.getNumberWaiting() + 1));

                cyclicBarrier.await();

                System.out.println(Thread.currentThread().getName() + " "
                        + System.currentTimeMillis() + " end No.2 phase "
                        + (cyclicBarrier.getNumberWaiting()));
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }

    public static class MyThread implements Runnable {

        private Service service;

        public MyThread(Service service) {
            this.service = service;
        }

        @Override
        public void run() {
            service.beginRun();
        }
    }
}

Run


Note:

CyclicBarrier类的parties值从1到2，然后再恢复到0，证明CyclicBarrier类的屏障点是可以复用的，另外线程1234每到达一个屏障点时的组合是随机的，sleep勇士最少的互相组合，继续向下一个屏障行进。 

 

isBroken()

isBroken()作用是查询屏障是否处于损坏状态

CyclicBarrierTest5.java

package org.fool.java.concurrent.cyclicbarrier;

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

public class CyclicBarrierTest5 {
    public static class MyService {
        private CyclicBarrier cyclicBarrier;

        public MyService(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }

        public void testMethod() {
            try {
                System.out.println(Thread.currentThread().getName() + " invoked..., wait for others...");

                if (Thread.currentThread().getName().equals("Thread-2")) {
                    System.out.println("Thread-2 ran into an accident!!!");
                    Thread.sleep(3000);
                    Integer.parseInt("a");
                    //Thread.currentThread().interrupt();
                }

                cyclicBarrier.await();

                System.out.println("All invoked..., begin to execute...");

                System.out.println(Thread.currentThread().getName() + " done...");
            } catch (InterruptedException e) {
                System.out.println(Thread.currentThread().getName() + " In InterruptedException e " + cyclicBarrier.isBroken());
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                System.out.println(Thread.currentThread().getName() + " In BrokenBarrierException e " + cyclicBarrier.isBroken());
                e.printStackTrace();
            }
        }
    }

    public static class MyThread implements Runnable {
        private MyService service;

        public MyThread(MyService service) {
            this.service = service;
        }

        @Override
        public void run() {
            service.testMethod();
        }
    }

    public static void main(String[] args) {
        CyclicBarrier cyclicBarrier = new CyclicBarrier(4, () -> System.out.println("All invoked..."));

        MyService service = new MyService(cyclicBarrier);

        for (int i = 0; i < 4; i++) {
            new Thread(new MyThread(service)).start();
        }
    }
}

Run


Note:

有一个程序出现异常报错，则其他线程继续等待，并不影响程序运行的主流程。

 

更改MyService.java的testMethod，注释掉Integer.parseInt("a")，添加interrupt()

if (Thread.currentThread().getName().equals("Thread-2")) {
	System.out.println("Thread-2 ran into an accident!!!");
	Thread.sleep(3000);
	//Integer.parseInt("a");
	Thread.currentThread().interrupt();
}

Run


Note:

所有线程都进入了catch块，其中Thread-2进入了InterruptedException块，其他3个线程进入了BrokenBarrierException块。CyclicBarrier处理线程的interrupt会使用全有或全无的破坏模型，意思是如果有一个线程由于中断或者超时提前离开了屏障点，其他所有在屏障点等待的线程也会抛出BrokenBarrierException或InterruptedException异常，并且离开屏障点。

 

await(long timeout, TimeUnit unit)

await(long timeout, TimeUnit unit)作用是如果在指定的时间内达到parties数量，则程序继续向下运行，否则如果出现超时，则抛出TimeoutException异常。

CyclicBarrierTest6.java

package org.fool.java.concurrent.cyclicbarrier;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CyclicBarrierTest6 {
    public static class MyService {
        private CyclicBarrier cyclicBarrier = new CyclicBarrier(3, () -> System.out.println("All done! " + System.currentTimeMillis()));

        public void testMethod() {
            try {
                System.out.println(Thread.currentThread().getName() + " prepare... " + System.currentTimeMillis());

                if(Thread.currentThread().getName().equals("Thread-0")) {
                    System.out.println("Thread-0 invoked cyclicBarrier.await(5, TimeUnit.SECONDS);");
                    cyclicBarrier.await(5, TimeUnit.SECONDS);
                }

                if(Thread.currentThread().getName().equals("Thread-1")) {
                    System.out.println("Thread-1 invoked cyclicBarrier.await();");
                    cyclicBarrier.await();
                }

                System.out.println(Thread.currentThread().getName() + " start... " + System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            } catch (TimeoutException e) {
                e.printStackTrace();
            }
        }
    }

    public static class MyThreadA implements Runnable {
        private MyService service;

        public MyThreadA(MyService service) {
            this.service = service;
        }

        @Override
        public void run() {
            service.testMethod();
        }
    }

    public static class MyThreadB implements Runnable {
        private MyService service;

        public MyThreadB(MyService service) {
            this.service = service;
        }

        @Override
        public void run() {
            service.testMethod();
        }
    }

    public static void main(String[] args) {
        MyService service = new MyService();

        Thread a = new Thread(new MyThreadA(service));
        a.start();

        Thread b = new Thread(new MyThreadB(service));
        b.start();
    }
}

Run


 

getNumberWaiting()和getParties()

getNumberWaiting()的作用是获取有几个线程已经到屏障点

getParties()的作用是获取parties的个数

CyclicBarrierTest7.java

package org.fool.java.concurrent.cyclicbarrier;

import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CyclicBarrierTest7 {
    public static class MyService {
        private CyclicBarrier cyclicBarrier = new CyclicBarrier(3, () -> System.out.println("All done! " + System.currentTimeMillis()));

        public void testMethod() {
            try {
                System.out.println(Thread.currentThread().getName() + " prepare... " + System.currentTimeMillis());

                if(Thread.currentThread().getName().equals("C")) {
                    Thread.sleep(Integer.MAX_VALUE);
                }

                cyclicBarrier.await();

                System.out.println(Thread.currentThread().getName() + " start... " + System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }

    public static class MyThreadA implements Runnable {
        private MyService service;

        public MyThreadA(MyService service) {
            this.service = service;
        }

        @Override
        public void run() {
            service.testMethod();
        }
    }

    public static class MyThreadB implements Runnable {
        private MyService service;

        public MyThreadB(MyService service) {
            this.service = service;
        }

        @Override
        public void run() {
            service.testMethod();
        }
    }

    public static class MyThreadC implements Runnable {
        private MyService service;

        public MyThreadC(MyService service) {
            this.service = service;
        }

        @Override
        public void run() {
            service.testMethod();
        }
    }

    public static void main(String[] args) {
        try {
            MyService service = new MyService();

            Thread a = new Thread(new MyThreadA(service));
            a.setName("A");
            a.start();

            Thread b = new Thread(new MyThreadB(service));
            b.setName("B");
            b.start();

            Thread c = new Thread(new MyThreadC(service));
            c.setName("C");
            c.start();

            Thread.sleep(3000);

            System.out.println(service.cyclicBarrier.getParties());

            System.out.println(service.cyclicBarrier.getNumberWaiting());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Run


 

reset()

reset()的作用是重置屏障 

CyclicBarrierTest8.java

package org.fool.java.concurrent.cyclicbarrier;

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

public class CyclicBarrierTest8 {
    public static class MyService {
        private CyclicBarrier cyclicBarrier = new CyclicBarrier(3, () -> System.out.println("All done! " + System.currentTimeMillis()));

        public void testMethod() {
            try {
                System.out.println(Thread.currentThread().getName() + " prepare... " + System.currentTimeMillis());

                cyclicBarrier.await();

                System.out.println(Thread.currentThread().getName() + " start... " + System.currentTimeMillis());
            } catch (InterruptedException e) {
                e.printStackTrace();
            } catch (BrokenBarrierException e) {
                e.printStackTrace();
            }
        }
    }

    public static class MyThreadA implements Runnable {
        private MyService service;

        public MyThreadA(MyService service) {
            this.service = service;
        }

        @Override
        public void run() {
            service.testMethod();
        }
    }

    public static class MyThreadB implements Runnable {
        private MyService service;

        public MyThreadB(MyService service) {
            this.service = service;
        }

        @Override
        public void run() {
            service.testMethod();
        }
    }

    public static class MyThreadC implements Runnable {
        private MyService service;

        public MyThreadC(MyService service) {
            this.service = service;
        }

        @Override
        public void run() {
            service.testMethod();
        }
    }

    public static void main(String[] args) {
        try {
            MyService service = new MyService();

            Thread a = new Thread(new MyThreadA(service));
            a.setName("A");
            a.start();

            Thread b = new Thread(new MyThreadB(service));
            b.setName("B");
            b.start();

            // thread c uninitialized
            Thread.sleep(3000);
            service.cyclicBarrier.reset();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Run


Note:

屏障被重置后，2个线程出现BrokenBarrierException 

 

 

Reference

Java并发编程核心方法与框架




 

Agile牧
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java多线程学习（九）CyclicBarrier学习
wanderlustLee的博客
02-26 503
CyclicBarrier类似于闭锁，但是CyclicBarrier要等待一组线程同时到达某个屏障，先到达的线程要等待其他线程到达，等达到了屏障要求的线程数量，这些线程才能继续执行。 API中的解释：CyclicBarrier是一个同步辅助类，它允许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待...
Java多线程同步工具之CyclicBarrier
lavimer
06-01 1082
CyclicBarrier表示大家彼此等待，只有当大家集合完毕之后才开始出发，分散活动后又在指定的dingy
CyclicBarrier的基本方法和应用场景实例
luzhensmart的专栏
01-28 478
1.CyclicBarrier简介 CyclicBarrier，是JDK1.5的java.util.concurrent并发包中提供的一个并发工具类。 所谓Cyclic即 循环 的意思，所谓Barrier即 屏障 的意思。 所以综合起来，CyclicBarrier指的就是 循环屏障，虽然这个叫法很奇怪，但是确能很好地表示它的作用。 其作用在JDK注释中是这样描述的： A synchron...
CyclicBarrier的工作原理及其实例
carson0408的博客
03-07 8153
        CyclicBarrier是多线程中一个重要的类，主要用于线程组内部之间的线程的相互等待问题。 1.CyclicBarrier的工作原理              CyclicBarrier大致是可循环利用的屏障，顾名思义，这个名字也将这个类的特点给明确地表示出来了。首先，便是可重复利用，说明该类创建的对象可以复用；其次，屏障则体现了该类的原理：每个线程执行时，都会碰到一个屏障，直...
concurrent-1.3.4.jar
最新发布
05-21
同步工具类：concurrent包提供了一些同步工具类，如CountDownLatch、CyclicBarrier、Semaphore等，可以帮助开发者实现复杂的线程协作和同步任务。 并发集合类：concurrent包提供了一些并发集合类，如...
concurrent-all-in-one.pdf
03-14
- `CyclicBarrier`：允许多个线程同步开始，等待所有线程到达屏障点后一起继续。 - `Semaphore`：信号量，用于限制同时访问特定资源的线程数量。 2. **同步机制** - `Synchronized`：关键字确保同一时间只有一个...
concurrent-1.3.4-sources.jar
11-13
5. **CyclicBarrier和Semaphore**：这两个类是同步辅助工具，CyclicBarrier用于一组线程互相等待，直到所有线程都到达屏障点后才能继续执行；Semaphore则用于限制同时访问特定资源的线程数量，常用于限流和保护共享...
backport-util-concurrent（2.2 /3.1）
08-14
- 在3.1版本中，backport-util-concurrent引入了Phaser，这是一个可重用的同步帮助器类，支持多个参与者之间的有界同步，类似于CyclicBarrier和CountDownLatch，但更灵活。Phaser可以自动调整参与者的数量，并且在...
Concurrent-programming:并发编程分配
05-16
学习这些内容可以帮助你深入理解如何在Java中编写高效的并发程序，包括如何避免线程安全问题，如何设计高并发应用，以及如何使用高级并发工具如`Semaphore`(信号量)、`CountDownLatch`(计数器门)和`CyclicBarrier`...
java concurrent 包下的CyclicBarrier方法
小十木的博客
06-11 238
CyclicBarrier用法 1、字面意思回环栅栏，通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用。我们暂且把这个状态就叫做barrier，当调用await()方法之后，线程就处于barrier了。 2、通俗的讲 就是 使用 CyclicBrarrier 几个线程在执行到需要进行栅栏的地方时 调用 Cyc...
java.util.concurrent.CyclicBarrier原理分析
APlus
09-13 433
一、引言 CyclicBarrier是Java并发工具包中的一个同步工具类，它允许一组线程互相等待，直到等待的线程达到指定数量后，所有等待的线程才会继续执行。我们可以称它为栅栏。 CyclicBarrier的构造方法有： 构造方法 解释 public CyclicBarrier(int parties) parties为等待线程的数量，等待的线程达到这个数后才会继...
Java并发编程之——CyclicBarrier的使用
EasyLiu
06-09 3460
首先看一下官方关于CyclicBarrier的简介： /** * A synchronization aid that allows a set of threads to all wait for * each other to reach a common barrier point. CyclicBarriers are * useful in programs involving
Java并发32:CyclicBarrier的基本方法和应用场景实例
韩超的博客 (hanchao5272)
04-01 1万+
[超级链接：Java并发学习系列-绪论] 本章主要对CyclicBarrier进行学习。 1.CyclicBarrier简介 CyclicBarrier，是JDK1.5的java.util.concurrent并发包中提供的一个并发工具类。 所谓Cyclic即 循环 的意思，所谓Barrier即 屏障 的意思。 所以综合起来，CyclicBarrier指的就是 循环屏障，虽然这个...
Java并发编程之CyclicBarrier详解
热门推荐
Stay Hungry, Stay Foolish
06-03 6万+
简介栅栏类似于闭锁，它能阻塞一组线程直到某个事件的发生。栅栏与闭锁的关键区别在于，所有的线程必须同时到达栅栏位置，才能继续执行。闭锁用于等待事件，而栅栏用于等待其他线程。CyclicBarrier可以使一定数量的线程反复地在栅栏位置处汇集。当线程到达栅栏位置时将调用await方法，这个方法将阻塞直到所有线程都到达栅栏位置。如果所有线程都到达栅栏位置，那么栅栏将打开，此时所有的线程都将被释放，而栅栏...
线程(七)---CyclicBarrier
FAIRYTAIL的博客
08-21 672
写在前面：各位看到此博客的小伙伴，如有不对的地方请及时通告私信我或者评论此博客的方式指出，以免误人子弟。多谢！ 概念： CyclicBarrier允许一组线程在到达某个栅栏点(common barrier point)互相等待，直到最后一个线程到达栅栏点，栅栏才会打开，处于阻塞状态的线程恢复继续执行。通过CyclicBarrier的await()方法，线程就处于barrier状态。找到一张动图很好的说明了CyclicBarrier的执行过程。 常用构造方法： 1.public CyclicB..
JAVA同步屏障CyclicBarrier
今天又是充满希望的一天
11-25 573
一：简单介绍同步屏障CyclicBarrier.       1.1 CyclicBarrier可以让一组线程到达一个屏障时被阻塞,直到最后一个线程到达屏障时,所有被屏障拦截的线程才会继续向下执行的.使用场景用于多线程计算数据.计算结果完成,插入同步屏障,阻塞等待.       1.2 CyclicBarrier位于java.util.concurrent包下.线程内执行CyclicBarri...
Java 线程并发 常用辅助类 (二) Cyclicbarrier
jiubadao1037的博客
11-13 285
定义介绍：允许一组线程全部等待彼此达到共同屏障点的同步辅助。循环阻塞在涉及固定大小的线程方的程序中很有用，这些线程必须偶尔等待彼此。屏障被称为循环，因为它可以在等待的线程被释放之后重新使用。 ACyclicBarrier支持一个可选的Runnable命令，每个屏障点运行一次，在派对中的最后一个线程到达之后，但在任何线程释放之前。在任何一方继续进行之前，此屏障操作对更新共享状态很有用。 构造方法： 构造方法 Constructor and Description CyclicBarrier(...
Java 并发编程学习笔记(8) ----CycliBarrier
过河的小卒子的博客
05-13 569
CyclicBarrier 的使用 1.介绍 可以实现屏障等待的功能（阶段性同步），同时可以循环实现要一起做任务的目标。 CyclicBarrier是一个同步辅助类，它允许一组线程互相等待，直到某个公告屏障点，这些线程必须相互等待。 2.CyclicBarrier 和 CountDownLatch 的区别: CountDownLatch:一个或多个线程，等待另外一个或多个线程完成某个事情之后...
介绍一下 java.util.concurrent.CyclicBarrier
05-29
`java.util.concurrent.CyclicBarrier`是一个多线程同步工具类，它可以让一组线程在达到某个屏障时相互等待，然后一起继续执行。它的作用类似于一个栅栏，所有线程必须到达栅栏前等待，当所有线程都到达后，栅栏才会...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值