java.util.concurrent.CyclicBarrier组件说明

1、CyclicBarrier

１、功能说明：一个同步辅助类，它容许一组线程互相等待，直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中，这些线程必须不时地互相等待，此时 CyclicBarrier 颇有用。由于该 barrier 在释放等待线程后能够重用，因此称它为循环 的 barrier（也翻译成栅栏）。

２、注意事项：CyclicBarrier能够使必定数量的参与方反复地在栅栏位置等待，经常用于模拟并发或者进行并行迭代计算。CyclicBarrier能够重置。

３、主要方法之构造方法CyclicBarrier(int parties)参数必须大于０的整数，这表示屏障点数量。

４、主要方法之等待CyclicBarrier.awit()在全部参与者都已经在此 barrier 上调用 await 方法以前，将一直等待。

５、主要方法之CyclicBarrier.getNumberWaiting()返回当前在屏障处等待的参与者数目。
６、主要方法之CyclicBarrier.isBroken() 查询此屏障是否处于损坏状态。
７、主要方法之CyclicBarrier.reset()  将屏障重置为其初始状态。

８、以下例所示，经常用于来模拟并发，下面来模拟１０个并发访问开源社区的首页。

注意：使用了第三方库(Jsoup)来解析html

Jsoup下载地址：jsoup-1.7.1.jar core library

package org.com.jsoup;

import java.io.IOException;
import java.util.concurrent.BrokenBarrierException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import org.jsoup.nodes.Element;
import org.jsoup.select.Elements;

public class CyclicBarrierTest {
    /**
     * 开源社区的首页地址
     */
	public final static String OSCHINA_HOME_PAGE = "http://www.oschina.net/";
	
	public static void getOschinaPage(final String url) throws IOException{
		//用了Jsoup库来解析html
		Document doc = Jsoup.connect(url).get();
		System.out.println(	doc.html().toString());
		Element content = doc.getElementById("M_A_home_items");
		if (content != null){
			Elements links = content.getElementsByTag("A");
			for (Element link : links) {
			   String linkHref = link.attr("href");
			   String linkText = link.text();
			   System.out.println(String.format("href地址：%s", linkHref));
			   System.out.println(String.format("a字符：%s", linkText));
			}
		}
		
	}
	/**
	 * @param args
	 * @throws InterruptedException 
	 */
	public static void main(String[] args) throws InterruptedException {
		  //开始时间
		   long beginTime =	 System.nanoTime();
		  
		　　final int theadMax = 10;
		　　//建立一个线程池,限制为最多theadMax个线程
		    final ExecutorService exec = Executors.newFixedThreadPool(theadMax);
		    //建立栅栏，指定数量为theadMax
			final CyclicBarrier cyclicBarrier = new CyclicBarrier(theadMax);
			//建立锁存器，设置为theadMax个，表示要等待theadMax个线程执行完
			final CountDownLatch downLatch = new CountDownLatch(theadMax);
			
			for(int i=0;i<theadMax;i++){
				Runnable runable = new Runnable(){
					@Override
					public void run() {
						try {
							//排队等待
							cyclicBarrier.await();
							System.out.println(String.format("线程：%s开始执行,当时时间：%d", Thread.currentThread().getName(),System.nanoTime()));
							//要执行的业务逻辑
							getOschinaPage(OSCHINA_HOME_PAGE);
						} catch (IOException e) {
							//处理异常
						} catch (InterruptedException e) {
							//处理异常
						} catch (BrokenBarrierException e) {
							//处理异常
						}finally{
							//减小计数值
							System.out.println(String.format("线程：%s执行完成,当时时间：%d", Thread.currentThread().getName(),System.nanoTime()));
							downLatch.countDown();	
						}
					}
				};
				//将任务放入线程池执行
			exec.execute(runable);
			}
			downLatch.await();//等待全部的并发访问完
			exec.shutdown();//关闭线程池
			System.out.println("执行完毕:" +( System.nanoTime() -beginTime));
	}

}