【线程同步工具】CyclicBarrier源码分析

最新推荐文章于 2024-07-29 14:22:26 发布
最新推荐文章于 2024-07-29 14:22:26 发布
阅读量380 收藏 1
点赞数
分类专栏： 并发编程 文章标签： java jvm 面试
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45645846/article/details/129476903
版权

在指定状态点同步任务

Java 并发 API 提供了可以使多个线程在一个指定点同步的工具类 CyclicBarrier，该类前文介绍的 CountDownLatch 有些类似，但是它的一些特殊性使得其更为强大。
CyclicBarrier 类的构造器需要有一个整型参数，这个参数表示在指定点进行同步 的线程个数。当需要同步的线程运行到指定点时，可以调用 CyclicBarrier 对象的 await()方法，然后等待其他线程达到指定点。这个方法使调用线程休眠，等待其他线程的到达。当最后一个需要同步的线程到达并调用 CyclicBarrier 对象的 await()方法 时（ 意味着所有的线程均已经到达需要同步的指定点。），所有在此等待的线程都会被唤醒并继续执行。
20181218144511688.gif
与CountDownLatch相比CyclicBarrier 可以有不止一个栅栏，它的栅栏（Barrier）可以重复使用（Cyclic）。
image.png
另外CyclicBarrier 类有一个有趣的优点，它提供的一个重载的构造方法可以额外接收一个 Runnable 类型的初始化参数。这样的话，CyclicBarrier 对象会在所有同步线程到达指定点后，将 Runnable 对象当作一个线程对象来执行。这个特点使得该类适合采用分而治之的编程技术来处理并发任务。

源码分析

主要属性

private static class Generation {
    boolean broken = false;
}

/** The lock for guarding barrier entry */
private final ReentrantLock lock = new ReentrantLock();
/** Condition to wait on until tripped */
private final Condition trip = lock.newCondition();
/** The number of parties */
private final int parties;
/* The command to run when tripped */
private final Runnable barrierCommand;
/** The current generation */
private Generation generation = new Generation();

private int count;

CyclicBarrier的核心属性共有6个，我们将它分为三组。

/** The number of parties */
private final int parties;
/**
* Number of parties still waiting. Counts down from parties to 0
* on each generation.  It is reset to parties on each new
* generation or when broken.
*/
private int count;

注意，这两个属性都是用来表示参与Barrier的线程数量，parties是Barrier要等待的线程数，也就是需要在该Barrier上进行同步的线程总数，是在构造函数中初始化并且不可更改的；count属性和CountDownLatch中的count一样，代表还需要等待的线程数，初始值为parties，每当一个线程到来就减一，如果该值为0，则说明所有的线程都到齐了，大家可以一起通过Barrier了。
第二组：

/** The lock for guarding barrier entry */
private final ReentrantLock lock = new ReentrantLock();
/** Condition to wait on until tripped */
private final Condition trip = lock.newCondition();
/** The current generation */
private Generation generation = new Generation();

这一组代表了CyclicBarrier的基础实现，使用了独占锁ReentrantLock和条件队列Condition。lock和trip是用来管理线程同步的，lock保证同一时刻只有一个线程可以访问障碍器，而trip则是一个等待队列，保存等待的线程。generation，用于标记当前障碍器的Barrier。
generation 这样解释你可能无法理解，再来看个形象点的解释。
由于CyclicBarrier是可重复使用的，所以我们把每一个新的barrier称为 generation。这个怎么理解呢，打个比方：一个过山车有10个座位，景区常常需要等够10个人了，才会去开动过山车。于是我们常常在栏杆（barrier）外面等，等凑够了10个人，工作人员就把栏杆打开，让10个人通过；然后再将栏杆归位，后面新来的人还是要在栏杆外等待。这里，前面已经通过的人就是一个generation，后面再继续等待的一波人就是另外一个 generation，栏杆每打开关闭一次，就产生新的 generation。
第三组：

/* The command to run when tripped */
private final Runnable barrierCommand;

这个属性是一个可选的Runnable，，表示当所有线程都到达障碍器时要执行的任务。如果不需要执行任务，则可以将该属性设置为null。这是一个很有趣的功能，在下面的使用案例中我会使用这个特点采用分而治之的编程技术来处理并发任务。
再用一张图来描绘下 CyclicBarrier 的一些属性和业务逻辑：
image.png

构造函数

CyclicBarrier有两个构造函数：

/**
* 创建一个新的CyclicBarrier，当给定数量的线程正在等待它时会被触发，屏障触发时不执行任何预定义的操作。
*
* @param parties 等待触发屏障的线程数量
* @throws IllegalArgumentException 如果parties小于1
*/
public CyclicBarrier(int parties) {
    this(parties, null); // 调用另一个构造函数，屏障触发时执行的操作为null
}

/**
* 创建一个新的CyclicBarrier，当给定数量的线程正在等待它时会被触发，
* 并且当屏障被触发时会由最后一个进入屏障的线程执行给定的屏障操作。
*
* @param parties 等待触发屏障的线程数量
* @param barrierAction 屏障触发时执行的操作，如果没有操作则为null
* @throws IllegalArgumentException 如果parties小于1
*/
public CyclicBarrier(int parties, Runnable barrierAction) {
    if (parties <= 0) throw new IllegalArgumentException();
    this.parties = parties; // 等待触发屏障的线程数量
    this.count = parties; // 等待触发屏障的线程数量
    this.barrierCommand = barrierAction; // 屏障触发时执行的操作，如果没有操作则为null
}

辅助方法

nextGeneration()

private void nextGeneration() {
    // 唤醒当前这一代中所有等待在条件队列里的线程
    trip.signalAll();
    // 恢复count值，开启新的一代
    count = parties;
    generation = new Generation();
}

该方法用于开启新的“一代”，通常是被最后一个调用await方法的线程调用。在该方法中，我们的主要工作就是唤醒当前这一代中所有等待在条件队列里的线程，将count的值恢复为parties，以及开启新的一代。

breakBarrier()

breakBarrier即打破现有的栅栏，让所有线程通过：

private void breakBarrier() {
    // 标记broken状态
    generation.broken = true;
    // 恢复count值
    count = parties;
    // 唤醒当前这一代中所有等待在条件队列里的线程（因为栅栏已经打破了）
    trip.signalAll();
}

这个breakBarrier怎么理解呢，继续拿上面过上车的例子打比方，有时候某个时间段，景区的人比较少，等待过山车的人数凑不够10个人，眼看后面迟迟没有人再来，这个时候有的工作人员也会打开栅栏，让正在等待的人进来坐过山车。这里工作人员的行为就是breakBarrier，由于并不是在凑够10个人的情况下就开启了栅栏，我们就把这一代的broken状态标记为true。

reset()

public void reset() {
    final ReentrantLock lock = this.lock;
    lock.lock();
    try {
        breakBarrier();   // break the current generation
        nextGeneration(); // start a new generation
    } finally {
        lock.unlock();
    }
}

CyclicBarrier 类提供的 reset()方法可以实现重置。当调用这个方法后，所有因调用 await()方法而休眠等待的线程，将收到 BrokenBarrierException 异常。在本 案例的异常处理中，会将异常信息栈打印输出。然而，在更复杂的应用中，可以在此处进 行其他处理，比如重启执行或者恢复中断点的操作。
值得注意的是，该方法执行前需要先获得锁。

await 方法

看完前面的辅助方法之后，接下来我们就来看 CyclicBarrier 最核心的 await方法，可以说整个CyclicBarrier最关键的只有它了。它也是一个集“countDown”和“阻塞等待”于一体的方法。
await方法有两种版本，一种带超时机制，一种不带，然而从源码上看，它们最终调用的都是带超时机制的dowait方法。

public int await() throws InterruptedException, BrokenBarrierException {
    try {
        return dowait(false, 0L);
    } catch (TimeoutException toe) {
        throw new Error(toe); // cannot happen
    }
}

public int await(long timeout, TimeUnit unit) throws InterruptedException, BrokenBarrierException, TimeoutException {
    return dowait(true, unit.toNanos(timeout));
}

CyclicBarrier 对象可以处于一个特殊的状态，被称为“损坏状态”。当多个线程 因调用 await() 方法而等待时，若其中一个被中断了，则此线程会收到 InterruptedException 异常，而其他线程将收到 BrokenBarrierException 异常，并且 CyclicBarrier 对象会进入损坏状态。 CyclicBarrier 类提供了 isBroken()方法。如果 CyclicBarrier 对象处于损坏 状态，则调用该方法将返回 true；否则，将返回 false。

dowait 方法

/**
* Barrier 主要代码，包含各种执行策略
*/
private int dowait(boolean timed, long nanos) throws InterruptedException, BrokenBarrierException, TimeoutException {
    final ReentrantLock lock = this.lock;
    // 所有执行await方法的线程必须是已经持有了锁，所以这里必须先获取锁
    lock.lock();
    try {
        final Generation g = generation;

        // 前面说过，调用breakBarrier会将当前“代”的broken属性设为true
        // 如果一个正在await的线程发现barrier已经被break了，则将直接抛出BrokenBarrierException异常
        if (g.broken)
            throw new BrokenBarrierException();

        // 如果当前线程被中断了，则先将栅栏打破，再抛出InterruptedException
        // 这么做的原因是，所以等待在barrier的线程都是相互等待的，如果其中一个被中断了，那其他的就不用等了。
        if (Thread.interrupted()) {
            breakBarrier();
            throw new InterruptedException();
        }

        // 当前线程已经来到了栅栏前，先将等待的线程数减一
        int index = --count;
        
        // 如果等待的线程数为0了，说明所有的parties都到齐了
        // 则可以唤醒所有等待的线程，让大家一起通过栅栏，并重置栅栏
        if (index == 0) {  // tripped
            boolean ranAction = false;
            try {
                final Runnable command = barrierCommand;
                if (command != null)
                    // 如果创建CyclicBarrier时传入了barrierCommand
                    // 说明通过栅栏前有一些额外的工作要做
                    command.run(); 
                ranAction = true;
                // 唤醒所有线程，开启新一代
                nextGeneration();
                return 0;
            } finally {
                if (!ranAction)
                    breakBarrier();
            }
        }

        // 如果count数不为0，就将当前线程挂起，直到所有的线程到齐，或者超时，或者中断发生
        for (;;) {
            try {
                // 如果没有设定超时机制，则直接调用condition的await方法
                if (!timed)
                    trip.await();  // 当前线程在这里被挂起
                else if (nanos > 0L)
                    // 如果设了超时，则等待指定的时间
                    nanos = trip.awaitNanos(nanos); // 当前线程在这里被挂起，超时时间到了就会自动唤醒
            } catch (InterruptedException ie) {
                // 执行到这里说明线程被中断了
                // 如果线程被中断时还处于当前这一“代”，并且当前这一代还没有被broken,则先打破栅栏
                if (g == generation && ! g.broken) {
                    breakBarrier();
                    throw ie;
                } else {
                    // 注意来到这里有两种情况
                    // 一种是g!=generation，说明新的一代已经产生了，所以我们没有必要处理这个中断，只要再自我中断一下就好，交给后续的人处理
                    // 一种是g.broken = true, 说明中断前栅栏已经被打破了，既然中断发生时栅栏已经被打破了，也没有必要再处理这个中断了
                    Thread.currentThread().interrupt();
                }
            }

            // 注意，执行到这里是对应于线程从await状态被唤醒了
            
            // 这里先检测broken状态，能使broken状态变为true的，只有breakBarrier()方法，到这里对应的场景是
            // 1. 其他执行await方法的线程在挂起前就被中断了
            // 2. 其他执行await方法的线程在还处于等待中时被中断了
            // 2. 最后一个到达的线程在执行barrierCommand的时候发生了错误
            // 4. reset()方法被调用
            if (g.broken)
                throw new BrokenBarrierException();

            // 如果线程被唤醒时，新一代已经被开启了，说明一切正常，直接返回
            if (g != generation)
                return index;

            // 如果是因为超时时间到了被唤醒，则打破栅栏，返回TimeoutException
            if (timed && nanos <= 0L) {
                breakBarrier();
                throw new TimeoutException();
            }
        }
    } finally {
        lock.unlock();
    }
}

dowait()方法里的整个逻辑分成两部分：
（1）最后一个线程走上面的逻辑，当count减为0的时候，打破栅栏，它调用nextGeneration()方法通知条件队列中的等待线程转移到AQS的队列中等待被唤醒，并进入下一代。
（2）非最后一个线程走下面的for循环逻辑，这些线程会阻塞在condition的await()方法处，它们会加入到条件队列中，等待被通知，当它们唤醒的时候已经更新换“代”了，这时候返回。
值得注意的是，await方法是有返回值的，代表了线程到达的顺序，第一个到达的线程的index为 parties - 1，最后一个到达的线程的index为 0

使用案例

案例一：赛马

Horse类

public class Horse implements Runnable {
    // 静态变量，用来记录马的数量
    private static int counter = 0;
    // 每匹马的编号
    private final int id = counter++;
    // 记录马已经走过的距离
    private int strides = 0;
    // 随机数生成器，用来生成每次随机跑几步
    private static Random rand = new Random(47);
    // CyclicBarrier 对象，用来控制所有马同时开始比赛
    private static CyclicBarrier barrier;

    // 构造函数，传入 CyclicBarrier 对象
    public Horse(CyclicBarrier b) { barrier = b; }

    // 实现 Runnable 接口中的 run() 方法
    @Override
    public void run() {
        try {
            // 只要线程没有被中断，就一直循环
            while(!Thread.interrupted()) {
                // 随机跑几步
                strides += rand.nextInt(3);
                // 等待所有的马准备好，才开始比赛
                barrier.await();
            }
        } catch(Exception e) {
            e.printStackTrace();
        }
    }

    // 返回当前马已经走过的距离的字符串表示
    public String tracks() {
        StringBuilder s = new StringBuilder();
        for(int i = 0; i < getStrides(); i++) {
            s.append("*");
        }
        s.append("Horse-" + id);
        return s.toString();
    }

    // 返回当前马已经走过的距离
    public int getStrides() { return strides; }
    // 返回当前马的编号
    public String toString() { return "Horse " + id + " "; }
}

HorseRace类

public class HorseRace implements Runnable {

    private static final int FINISH_LINE = 80;

    private List<Horse> horses; // 赛马列表
    private ExecutorService exec; // 线程池

    public HorseRace(List<Horse> horses, ExecutorService exec) {
        this.horses = horses;
        this.exec = exec;
    }

    @Override
    public void run() {
        StringBuilder s = new StringBuilder();
        // 打印赛道边界
        for (int i = 0; i < FINISH_LINE; i++) {
            s.append("=");
        }
        System.out.println(s);
        // 打印赛马轨迹
        for (Horse horse : horses) {
            System.out.println(horse.tracks());
        }
        // 判断是否结束
        for (Horse horse : horses) {
            if (horse.getStrides() >= FINISH_LINE) {
                System.out.println(horse + "won!");
                exec.shutdownNow(); // 中断线程池中的所有线程
                return;
            }
        }
        // 休息指定时间再到下一轮
        try {
            TimeUnit.MILLISECONDS.sleep(200);
        } catch (InterruptedException e) {
            System.out.println("barrier-action sleep interrupted");
        }
    }

}

Main类

public class Main {

    // 创建一个马的列表，使用ArrayList存储
    private static List<Horse> horses = new ArrayList<Horse>();

    // 创建一个线程池，使用newCachedThreadPool方法创建一个可缓存的线程池
    private static ExecutorService exec = Executors.newCachedThreadPool();

    public static void main(String[] args) {
        // 创建一个CyclicBarrier对象，用于等待所有马准备就绪后开始比赛
        // 这里设置7个参与者，当有7个线程到达await方法时，会执行HorseRace的run方法
        CyclicBarrier barrier = new CyclicBarrier(7, new HorseRace(horses, exec));

        // 循环创建7匹马，将它们添加到马列表中，并且提交到线程池中执行
        for(int i = 0; i < 7; i++) {
            Horse horse = new Horse(barrier);
            horses.add(horse);
            exec.execute(horse);
        }
    }
}

该赛马程序主要是通过在控制台不停的打印各赛马的当前轨迹，以此达到动态显示的效果。整场比赛有多个轮次，每一轮次各个赛马都会随机走上几步然后调用await方法进行等待，当所有赛马走完一轮的时候将会执行任务将所有赛马的当前轨迹打印到控制台上。这样每一轮下来各赛马的轨迹都在不停的增长，当其中某个赛马的轨迹最先增长到指定的值的时候将会结束整场比赛，该赛马成为整场比赛的胜利者！
程序的运行结果如下：
20181218144511713.gif

案例二：分而治之

MatrixMock 类

/**
 * 该类生成一个介于1和10之间的整数随机矩阵
 */
public class MatrixMock {

	/**
	 * 包含随机数的二维数组
	 */
	private final int data[][];

	/**
	 * 类的构造函数。生成二维数组。
	 * 在生成数组时，计算出指定要查找的数字出现的次数，以便检查CyclicBarrier类的工作是否良好。
	 * @param size 数组的行数
	 * @param length 数组的列数
	 * @param number 要查找的数字
	 */
	public MatrixMock(int size, int length, int number){

		int counter=0; // 计数器初始化为0
		data=new int[size][length]; // 生成指定行数和列数的二维整数数组
		Random random=new Random(); // 创建一个Random对象
		for (int i=0; i<size; i++) {
			for (int j=0; j<length; j++){
				data[i][j]=random.nextInt(10); // 用随机数填充数组
				if (data[i][j]==number){ // 如果数组中的元素等于指定数字
					counter++; // 计数器递增
				}
			}
		}
		System.out.printf("Mock: 在生成的数据中有%d个数字%d的出现。\n", counter, number); // 输出指定数字出现的次数
	}


	/**
	 * 该方法返回二维数组的一行
	 * @param row 要返回的行号
	 * @return 所选行
	 */
	public int[] getRow(int row){
		if ((row>=0)&&(row<data.length)){ // 如果指定的行号在数组的索引范围内
			return data[row]; // 返回指定行的数组
		}
		return null; // 否则返回null
	}


}

Results类

/**
 * 该类用于存储我们在二维数组的每行中查找的数字的出现次数
 */
public class Results {

	/**
	 * 用于存储每行中数字出现次数的数组
	 */
	private final int data[];

	/**
	 * 该类的构造函数，用于初始化它的属性
	 * @param size 用于存储结果的数组的大小
	 */
	public Results(int size){
		data=new int[size];
	}

	/**
	 * 设置结果数组中一个位置的值
	 * @param position 数组中的位置
	 * @param value 要设置的值
	 */
	public void setData(int position, int value){
		data[position]=value;
	}

	/**
	 * 返回结果数组
	 * @return 结果数组
	 */
	public int[] getData(){
		return data;
	}
}

Search类

/**
 * 在二维数组的一组行中查找指定的数字
 */
public class Searcher implements Runnable {

	/**
	 * 需要查找的数字
	 */
	private final int number;

	/**
	 * 待查找的二维数组
	 */
	private final MatrixMock mock;

	/**
	 * 结果数组
	 */
	private final Results results;

	/**
	 * 需要查找的行范围
	 */
	private final int firstRow, lastRow;

	/**
	 * 同步屏障，用于控制任务的执行
	 */
	private final CyclicBarrier barrier;

	/**
	 * 构造函数，用于初始化类属性
	 * @param firstRow 查找的起始行号
	 * @param lastRow 查找的结束行号
	 * @param mock 待查找的二维数组
	 * @param results 存储结果的结果数组
	 * @param number 需要查找的数字
	 * @param barrier 同步屏障，用于控制任务的执行
	 */
	public Searcher(int firstRow, int lastRow, MatrixMock mock, Results results, int number, CyclicBarrier barrier) {
		this.firstRow = firstRow;
		this.lastRow = lastRow;
		this.mock = mock;
		this.results = results;
		this.number = number;
		this.barrier = barrier;
	}

	/**
	 * 每行查找数字并将结果存储到结果数组中
	 */
	@Override
	public void run() {
		int counter;
		System.out.printf("%s: 正在处理从第%d行到第%d行的数据\n", Thread.currentThread().getName(), firstRow, lastRow);
		for (int i = firstRow; i < lastRow; i++) {
			int row[] = mock.getRow(i); // 获取第i行
			counter = 0;
			for (int j = 0; j < row.length; j++) {
				if (row[j] == number) { // 在行中查找数字
					counter++; // 数字出现次数+1
				}
			}
			results.setData(i, counter); // 将数字出现次数存储到结果数组中
		}
		System.out.printf("%s: 处理完毕\n", Thread.currentThread().getName());
		try {
			barrier.await(); // 等待其他任务完成
		} catch (InterruptedException e) {
			e.printStackTrace();
		} catch (BrokenBarrierException e) {
			e.printStackTrace();
		}
	}
}

Group类

/**
 * 将每个Searcher的结果分组。将存储在Results对象中的值相加
 * 当所有Searcher完成其工作时，此类的对象会被CyclicBarrier自动执行
 */
public class Grouper implements Runnable {

	/**
	 * 存储每一行中数字出现次数的Results对象
	 */
	private final Results results;

	/**
	 * 类的构造方法。初始化它的属性
	 * @param results 存储每一行数字出现次数的Results对象
	 */
	public Grouper(Results results){
		this.results=results;
	}

	/**
	 * Grouper的主方法。将存储在Results对象中的值相加
	 */
	@Override
	public void run() {
		int finalResult=0;
		System.out.printf("Grouper: 数据个数统计中...\n");
		int data[]=results.getData();
		for (int number:data){
			finalResult+=number;
		}
		System.out.printf("Grouper: 数据出现的个数: %d.\n",finalResult);
	}

}

Main类

/**
 * 示例的主类
 */
public class Main {
	/**
	 * 示例的主方法
	 * @param args 命令行参数
	 */
	public static void main(String[] args) {
		/*
		 * 初始化二维数据数组
		 * 		10000行
		 * 		每行1000个数字
		 * 		查找数字5
		 */
		final int ROWS=10000;
		final int NUMBERS=1000;
		final int SEARCH=5;
		final int PARTICIPANTS=5;
		final int LINES_PARTICIPANT=2000;
		MatrixMock mock=new MatrixMock(ROWS, NUMBERS,SEARCH);

		// 初始化结果对象
		Results results=new Results(ROWS);

		// 创建 Grouper 对象
		Grouper grouper=new Grouper(results);

		// 创建 CyclicBarrier 对象。它有5个参与者，当他们完成时，CyclicBarrier 将执行 grouper 对象
		CyclicBarrier barrier=new CyclicBarrier(PARTICIPANTS,grouper);

		// 创建、初始化并启动5个 Searcher 对象
		Searcher searchers[]=new Searcher[PARTICIPANTS];
		for (int i=0; i<PARTICIPANTS; i++){
			searchers[i]=new Searcher(i*LINES_PARTICIPANT, (i*LINES_PARTICIPANT)+LINES_PARTICIPANT, mock, results, 5,barrier);
			Thread thread=new Thread(searchers[i]);
			thread.start();
		}
		System.out.printf("Main: 主线程完成.\n");
	}
}

这个案例所解决的问题比较简单，有一个大矩阵，其元素为 0～9 的随机整数，想要知道某个数字在其中出现的次数。为了提升查询效率，可以采用分而治之的方法，将矩阵划 分为 5 个子集，采用多线程的方式分别统计每个子集中某个数字出现的次数。这些线程执行的任务为 Searcher 对象。 在这里，可以采用一个 CyclicBarrier 对象来同步 5 个线程的完成状态 ( 使得在 5 个线程均完成统计任务后，执行 Grouper 任务。)。
对每个线程统计结果进行汇总得到最后结果。 正如之前介绍，CyclicBarrier 类定义了内部计数器，它对需要在同步状态点进行同步的线程数进行控制。每当一个线程执行到同步状态点时，它会通过调用 await()通知 CyclicBarrier 对象有一个线程已达到同步状态点，这时 CyclicBarrier 对象将内部计数器的值减 1，并将调用线程休眠，直到所有线程均达到同步状态点。 当所有线程均达到同步状态点后，CyclicBarrier 对象将唤醒所有因调用该对象 await()方法而休眠等待的线程，并且该对象还会创建一个新的线程来执行在CyclicBarrier 构造器中传入的Runnable 对象（在本问中，这指Grouper 对象）。

运行结果：

image.png

参考资料

程序员Alan
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
多线程编程之CyclicBarrier 源码分析
游戈程序员
06-22 132
CyclicBarrier 源码分析之怎么卷死 CountDownLatch CyclicBarrier 是什么？ CyclicBarrier 一般称为栅栏、屏障，是一种多线程同步工具。 常常和 CountDownLatch一起作比较，因为都属于用于一组线程等待的工具。 不同于 CountDownLatch常用于协调线程等待一组工作线程，且工作线程到达后做一次通知并继续执行，CyclicBarrier 人如其名的是一组线程相互等待全部到达指定处后，再全部继续执行。 CyclicBarrier更高级的是：
Java并发系列之CyclicBarrier源码分析
08-27
Java并发系列之CyclicBarrier源码分析 CyclicBarrier是Java并发系列中的一种同步工具类，用于实现一组线程相互等待。当所有线程都到达某个屏障点后，再进行后续的操作。下面是对CyclicBarrier源码的详细分析。 ...
CyclicBarrier源码分析
爱琴孩的博客
04-05 885
前言 前面，我们在CountDownLatch和CyclicBarrier那点事中简单介绍了CountDownLatch和CyclicBarrier中的使用小demo，同时比对了这两个线程协作工具的特点。这里来和大家一起看看CyclicBarrier的源码。 瞅源码 先看看CyclicBarrier的类图接口 CyclicBarrier其实很简单。从类结构中看到有： await() 方法，猜测应该和 CountDownLatch 是类似的，都是获取同步状态，阻塞自己 Reentr
CyclicBarrier源码-JUC线程同步工具3
mayongzhan_csdn的专栏
07-16 664
CyclicBarrier源码-JUC线程同步工具3 这是线程同步的第三个工具类，跟前文CountDownLatch 如果理解不深入，会觉得他们很相似，觉得都是一个主线程在等待其它子线程完成自己的任务，主线程运行。本文会介绍它们两个的区别，以及内部实现。 何为CyclicBarrier CyclicBarrier 是一个让一系列线程集合互相等待直到一个公共屏障点(barrier point)...
java多线程工具_Java多线程同步工具类之CyclicBarrier
weixin_34717586的博客
03-08 67
释放双眼，带上耳机，听听看~！一、CyclicBarrier使用CyclicBarrier从字面上可以直接理解为线程运行的屏障，它可以让一组线程执行到一个共同的屏障点时被阻塞，直到最后一个线程执行到指定位置，你设置的执行线程就会触发运行；同时CyclicBarrier相比与CountDownLatch，它是可以被重置的；下面我们通过一个简单例子看下CyclicBarrier的使用；实例化一个Cyc...
并发工具CyclicBarrier源码分析及应用
猿灯塔的博客
03-31 185
今天是猿灯塔“365天原创计划”第3天。 今天呢！灯塔君跟大家讲： 并发工具CyclicBarrier源码分析及应用 一.CyclicBarrier简介 1.简介 CyclicBarrier是一个同步的辅助类，允许一组线程相互之间等待，达到一个共同点，再继续执行。 CyclicBarrier（循环屏障） 直译为可循环使用（Cyclic）的屏障（Barrier）。它可以让一组线程到 达一个屏障（同...
JUC并发工具之CyclicBarrier源码分析
zhangzw的博客
05-13 193
CyclicBarrier顾名思义就是可循环使用的屏障。它主要实现的功能是让一组线程到达一个屏障(也可以叫同步点)时阻塞，直到最后一个线程到达屏障时，屏障才会放行，所有被屏障拦截的线程才可以继续运行。 CyclicBarrier结构 CyclicBarrier结构如下： 通过上图我们可以看到，CyclicBarrier是通过ReentrantLock和Condition来实现的。它有两个构造方法，其源码如下： public CyclicBarrier(int parties) { this(par
JUC之CyclicBarrier源码分析
程序员江哥的博客
02-25 52
【代码】JUC之CyclicBarrier源码分析。
java线程同步barrier_Java多线程同步工具类之CyclicBarrier
weixin_28748675的博客
02-26 155
一、CyclicBarrier使用CyclicBarrier从字面上可以直接理解为线程运行的屏障，它可以让一组线程执行到一个共同的屏障点时被阻塞，直到最后一个线程执行到指定位置，你设置的执行线程就会触发运行；同时CyclicBarrier相比与CountDownLatch，它是可以被重置的；下面我们通过一个简单例子看下CyclicBarrier的使用；实例化一个CyclicBarrier对象并传入...
线程同步工具
weixin_41816847的博客
04-14 255
主要对比线程同步工具：CountDownLatch、CyclicBarrier、Semaphore 【前言】 在一个主线程有多个子线程并发执行，如果不做任何处理，主线程跑完后，有可能拿不到子线程的执行结果用于业务处理。所以通常都需要在主线程中对于子线程进行join方法的调用，使得主线程阻塞，等待子线程执行完后再进行主线程的代码执行。 【例子：】 public stat...
基于java开发的多线程下载工具（源码）
05-28
《基于Java开发的多线程下载工具》 在IT领域，高效的文件下载是不可或缺的一环...通过分析和研究这个源码，开发者不仅可以加深对Java编程的理解，还能掌握多线程下载工具的开发技巧，为自己的项目开发提供宝贵的经验。
线程同步器CycliBarrier你都不会吗?
12-21
CyclicBarrier是Java并发库中的一个强大工具，它提供了一种高效的方式让一组线程同步执行。通过合理的配置和使用，开发者可以利用CyclicBarrier来控制并发流程，确保在关键点上的正确同步，从而提高程序的并发性能和...
并发编程、juc工具包源码分析笔记
11-03
并发编程是多线程环境下的程序设计，它允许在单个处理器或多个处理器上同时执行...CountDownLatch、CyclicBarrier、Semaphore 等工具）。理解这些工具的工作原理和使用场景，能够帮助开发者编写高效且安全的并发程序。
28个java常用的工具类源码
04-07
18. **CountDownLatch和CyclicBarrier**：同步原语，用于多线程间的协调。 19. **Semaphore**：信号量，用于控制并发访问的资源数量。 20. **Future和ExecutorService**：异步编程和任务调度的重要组件。 21. **...
java springboot 集成 阿里通义千问
qq_25987725的博客
07-25 392
一、在阿里云https://www.aliyun.com官网直接搜索“通义千问”，点击“开通DashScope”进行服务激活。四、在config目录添加配置 TongYiAiConfiguration.java。三、在yml中配置中配置key。二、加入Maven依赖。
使用hutool工具判断字符串是否全部是字母(包括大小写)，java判断字符串是否全部是字母(包括大小写)
最新发布
qq_43700885的博客
07-29 444
1.导入hutool的maven依赖。2.复制一下代码执行。
java判断邮箱地址是否正确，使用hutool工具判断邮箱地址是否正确
qq_43700885的博客
07-29 243
1.导入hutool的maven依赖。2.直接复制一下代码运行。
Swagger使用Map接受参数时，页面如何显示具体参数及说
a1058926697的博客
07-26 616
后端使用Map接受参数，要求在swagger页面上显示具体的参数名称、类型及说明。当Map接受参数数量少时，可以使用Swagger自带的注解。自定义注解 @ApiGlobalModel。编写处理注解对应的插件。
Java线程同步：避免数据破坏的关键技术
Java 5引入了并发工具类，如`Semaphore`（信号量），`CyclicBarrier`（回环栅栏），`CountDownLatch`（倒计时器）等，提供更高级别的同步和协调机制。 5. **ReentrantLock可重入锁** `java.util.concurrent.locks...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值