Java并发编程-13-在集合点的同步-CyclicBarrier

一、CyclicBarrier同步辅助类

作用：允许两个或者多个线程在某个点上进行同步

1、CyclicBarrier类使用一个整型数进行初始化，这个数是需要在某个点上同步的线程数

2、当一个线程到达指定的点后，它将调用await()方法等待其他线程。当线程调用await()方法后，CyclicBarrier类将阻塞这个线程并使之休眠直到其他所有线程到达

3、当最后一个线程调用CyclicBarrier类的await()方法时，CyclicBarrier将唤醒所有在等待的线程，然后这个线程将继续执行

CyclicBarrier：可以传入一个Runnable对象作为初始化参数，当所有的线程都到达集合点之后，CyclicBarrier将这个Runnable对象作为线程执行

二、模拟实现

在一个矩阵中查找一个数字

将矩阵分成几个小矩阵，每个线程都在一个子集中查找。一旦所有的线程完成查找，对中的任务将统一这些结果

package com.concurrent.threadAvgClass;

import java.util.Random;

public class MatrixMock {

	private int[][] data;

	public MatrixMock(int size, int length, int target) {
		int counter = 0;
		data = new int[size][length];
		Random random = new 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] == target)
					counter++;
			}
		}

		System.out
				.printf("Mock : There are %d ocurrences of number in generated data.\n",
						counter, target);
	}

	public int[] getRow(int row) {
		if ((row >= 0) && (row < data.length)) {
			return data[row];
		}
		return null;
	}
}

package com.concurrent.threadAvgClass;

/**
 * 这个类是一个结果类
 * 这个类保存矩阵中每行找到的指定数字的次数
 * @author Nicholas
 *
 */
public class Result {

	private int[] data;

	public Result(int size) {
		data = new int[size];
	}
	
	public void setData(int position,int value) {
		data[position] = value;
	}
	
	public int[] getData() {
		return data;
	}
}

package com.concurrent.threadAvgClass;

public class Grouper implements Runnable{

	private Result result;
	
	public Grouper(Result result) {
		this.result = result;
	}

	@Override
	public void run() {
		int finalResult = 0;
		System.out.println("Grouper : Processing results\n");
		int[] data = result.getData();
		for(int number:data) {
			finalResult += number;
		}
		System.out.println("Grouper : Total results : "+finalResult);
	}	
}

package com.concurrent.threadAvgClass;

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


/**
 * 这是查找类
 * @author Nicholas
 * 这个类在随机矩阵中指定的行中查找某个数
 */
public class Searcher implements Runnable {

	private int firstRow;
	private int lastRow;

	private MatrixMock matrixMock;
	private Result result;
	private int number;

	private final CyclicBarrier cyclicBarrier;

	public Searcher(int firstRow, int lastRow, MatrixMock matrixMock,
			Result result, int number, CyclicBarrier cyclicBarrier) {
		this.firstRow = firstRow;
		this.lastRow = lastRow;
		this.matrixMock = matrixMock;
		this.result = result;
		this.number = number;
		this.cyclicBarrier = cyclicBarrier;
	}

	@Override
	public void run() {
		int counter;//存放每行查找到的次数
		System.out.printf("%s : Processing lines from %d to %d.\n", Thread
				.currentThread().getName(), firstRow, lastRow);

		for (int i = firstRow; i < lastRow; i++) {
			int row[] = matrixMock.getRow(i);
			counter = 0;
			for (int j = 0; j < row.length; j++) {
				if (row[j] == number)
					counter++;
			}
			result.setData(i, counter);
		}
		System.out.printf("%s : Processing lines finished\n", Thread
				.currentThread().getName());
		
		try {
			cyclicBarrier.await();
		} catch (InterruptedException | BrokenBarrierException e) {
			e.printStackTrace();
		}
	}
}

package com.concurrent.threadAvgClass;

import java.util.concurrent.CyclicBarrier;

public class Main2 {

	public static void main(String[] args) {
		final int ROWS = 10000;
		final int NUMBERS = 1000;
		final int SEARCH = 5;
		final int PARTICIPANTS = 5;
		final int LINES_PARTICIPENT = 2000;

		MatrixMock matrixMock = new MatrixMock(ROWS, NUMBERS, SEARCH);
		Result result = new Result(ROWS);
		Grouper grouper = new Grouper(result);

		CyclicBarrier cyclicBarrier = new CyclicBarrier(PARTICIPANTS, grouper);

		Searcher[] searcher = new Searcher[PARTICIPANTS];
		for (int i = 0; i < PARTICIPANTS; i++) {
			searcher[i] = new Searcher(i * LINES_PARTICIPENT,
					(i * LINES_PARTICIPENT) + LINES_PARTICIPENT, matrixMock,
					result, 5, cyclicBarrier);
			Thread thread = new Thread(searcher[i]);
			thread.start();
		}
		System.out.println("Main : The main thread has been finished..");
	}
}

三、cyclicBarrier与CountDownLatch比较

cyclicBarrier还提供的方法：

getNumberWairing() 返回在await()上阻塞的线程的数目

getParties() 返回被cyclicBarrier对象同步的任务数

cyclicBarrier可以被重置到初始状态，并把内部的计数器重置成初始化的值 对应的函数 reset()

cyclicBarrier对象有一种特殊的状态----损坏状态。

当很多线程在等待的时候，如果其中一个线程被中断，这个线程将抛出InterruptedException异常

其他等待的线程抛出BrokenBarrierException异常。于是cyclicBarrier对象就处于损坏状态了，可以使用isBroken()方法检测cyclicBarrier对象的状态