java5中为多线程提供的同步工具类

最新推荐文章于 2012-11-29 22:22:23 发布

xh16319

最新推荐文章于 2012-11-29 22:22:23 发布

阅读量767

点赞数

分类专栏：多线程

本文链接：https://blog.csdn.net/xh16319/article/details/8236438

版权

多线程专栏收录该内容

16 篇文章 0 订阅

订阅专栏

IT程序员开发必备-各类资源下载清单，史上最全IT资源，个人收藏总结！

1、Semaphore实现信号灯

    (1)Semaphore可以维护当前访问自身的线程个数，并提供了同步机制。使用Semaphore可以控制同时访问资源的线程个数，例如，实现一个文件允许的并发访问数。
          A、 Semaphore实现的功能就类似厕所有5个坑，假如有十个人要上厕所，那么同时能有多少个人去上厕所呢？同时只能有5个人能够占用，当5个人中的任何一个人让开后，其中在等待的另外5个人中又有一个可以占用了。
         B、另外等待的5个人中可以是随机获得优先机会，也可以是按照先来后到的顺序获得机会，这取决于构造Semaphore对象时传入的参数选项。
    (2)单个信号量的Semaphore对象可以实现互斥锁的功能，并且可以是由一个线程获得了“锁”，再由另一个线程释放“锁”，这可应用于死锁恢复的一些场合

2.CyclicBarrier它允许一组线程互相等待，直到到达某个公共屏障点

表示大家彼此等待，大家集合好后才开始出发，分散活动后又在指定地点集合碰面，这就好比整个公司的人员利用周末时间集体郊游一样，先各自从家出发到公司集合后，再同时出发到公园游玩，在指定地点集合后再同时开始就餐，…。

3.CountDownLatch 在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待

(1)犹如倒计时计数器，调用CountDownLatch对象的countDown方法就将计数器减1，当计数到达0时，则所有等待者或单个等待者开始执行。这直接通过代码来说明CountDownLatch的作用，这样学员的理解效果更直接。
(2)可以实现一个人（也可以是多个人）等待其他所有人都来通知他，这犹如一个计划需要多个领导都签字后才能继续向下实施。还可以实现一个人通知多个人的效果，类似裁判一声口令，运动员同时开始奔跑。用这个功能做百米赛跑的游戏程序不错哦！

4.Exchanger 可以在对中对元素进行配对和交换的线程的同步点

用于实现两个人之间的数据交换，每个人在完成一定的事务后想与对方交换数据，第一个先拿出数据的人将一直等待第二个人拿着数据到来时，才能彼此交换数据。

例子程序

Semaphore工具类:

package edu.java5.util;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
public class SemaphoreTest {
	public static void main(String[] args) {
		ExecutorService service = Executors.newCachedThreadPool();
		final  Semaphore sp = new Semaphore(3);
		for(int i=0;i<10;i++){
			Runnable runnable = new Runnable(){
					public void run(){
					try {
						sp.acquire();
					} catch (InterruptedException e1) {
						e1.printStackTrace();
					}
					System.out.println("线程" + Thread.currentThread().getName() + 
							"进入，当前已有" + (3-sp.availablePermits()) + "个并发");
					try {
						Thread.sleep((long)(Math.random()*10000));
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					System.out.println("线程" + Thread.currentThread().getName() + 
							"即将离开");					
					sp.release();
					//下面代码有时候执行不准确，因为其没有和上面的代码合成原子单元
					System.out.println("线程" + Thread.currentThread().getName() + 
							"已离开，当前已有" + (3-sp.availablePermits()) + "个并发");					
				}
			};
			service.execute(runnable);			
		}
	}

}

/**
 * 结果:
          线程pool-1-thread-1进入，当前已有1个并发
	线程pool-1-thread-3进入，当前已有2个并发
	线程pool-1-thread-5进入，当前已有3个并发
	线程pool-1-thread-5即将离开
	线程pool-1-thread-5已离开，当前已有2个并发
	线程pool-1-thread-7进入，当前已有3个并发
	线程pool-1-thread-3即将离开
	线程pool-1-thread-3已离开，当前已有2个并发
	线程pool-1-thread-2进入，当前已有3个并发
	线程pool-1-thread-1即将离开
	线程pool-1-thread-1已离开，当前已有2个并发
	线程pool-1-thread-4进入，当前已有3个并发
	线程pool-1-thread-4即将离开
	线程pool-1-thread-4已离开，当前已有2个并发
	线程pool-1-thread-9进入，当前已有3个并发
	线程pool-1-thread-7即将离开
	线程pool-1-thread-10进入，当前已有3个并发
	线程pool-1-thread-7已离开，当前已有3个并发
	线程pool-1-thread-2即将离开
	线程pool-1-thread-8进入，当前已有3个并发
	线程pool-1-thread-2已离开，当前已有3个并发
	线程pool-1-thread-10即将离开
	线程pool-1-thread-6进入，当前已有3个并发
	线程pool-1-thread-10已离开，当前已有3个并发
	线程pool-1-thread-9即将离开
	线程pool-1-thread-9已离开，当前已有2个并发
	线程pool-1-thread-8即将离开
	线程pool-1-thread-8已离开，当前已有1个并发
	线程pool-1-thread-6即将离开
	线程pool-1-thread-6已离开，当前已有0个并发
 * */

CyclicBarrier工具类:

package edu.java5.util;

import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
 * 讲解CyclicBarrier的功能时，通过辅助画图的方式说明，效果会更好。
	\            /
	 \     |    /
   ------------------------三个线程干完各自的任务，在不同的时刻到达集合点后，就可以接着忙各自的工作去了，再到达新的集合点，再去忙各自的工作，
					到达集合点了用CyclicBarrier对象的await方法表示等待其他线程在此集合。
	  /     |   \
	 /     |    \
      -------------------
		为什么几个人能碰到一起，说白了，就是大家都把手头这一阶段的工作做完了，就可以碰到一起了。
		譬如，我下楼等方老师，就是等他手头工作做完了，到达了它要集合的状态，就集合了。
		
 **/
public class CyclicBarrierTest {

	public static void main(String[] args) {
		ExecutorService service = Executors.newCachedThreadPool();
		final  CyclicBarrier cb = new CyclicBarrier(3);
		for(int i=0;i<3;i++){
			Runnable runnable = new Runnable(){
					public void run(){
					try {
						Thread.sleep((long)(Math.random()*10000));	
						System.out.println("线程" + Thread.currentThread().getName() + 
								"即将到达集合地点1，当前已有" + (cb.getNumberWaiting()+1) + "个已经到达，正在等候");						
						cb.await();
						System.out.println("三个线程都到达集合地点1，出发至集合地点2");
						Thread.sleep((long)(Math.random()*10000));	
						System.out.println("线程" + Thread.currentThread().getName() + 
								"即将到达集合地点2，当前已有" + (cb.getNumberWaiting()+1) + "个已经到达，正在等候");						
						cb.await();	
						System.out.println("都到达集合地点2，出发至集合地点3");
						Thread.sleep((long)(Math.random()*10000));	
						System.out.println("线程" + Thread.currentThread().getName() + 
								"即将到达集合地点3，当前已有" + (cb.getNumberWaiting()+1) + "个已经到达，正在等候");						
						cb.await();		
						System.out.println("集合完毕，到达目的地");
					} catch (Exception e) {
						e.printStackTrace();
					}				
				}
			};
			service.execute(runnable);
		}
		service.shutdown();
	}
}
/**
 * 结果:
 *  线程pool-1-thread-2即将到达集合地点1，当前已有1个已经到达，正在等候
	线程pool-1-thread-3即将到达集合地点1，当前已有2个已经到达，正在等候
	线程pool-1-thread-1即将到达集合地点1，当前已有3个已经到达，正在等候
	三个线程都到达集合地点1，出发至集合地点2
	三个线程都到达集合地点1，出发至集合地点2
	三个线程都到达集合地点1，出发至集合地点2
	线程pool-1-thread-1即将到达集合地点2，当前已有1个已经到达，正在等候
	线程pool-1-thread-3即将到达集合地点2，当前已有2个已经到达，正在等候
	线程pool-1-thread-2即将到达集合地点2，当前已有3个已经到达，正在等候
	都到达集合地点2，出发至集合地点3
	都到达集合地点2，出发至集合地点3
	都到达集合地点2，出发至集合地点3
	线程pool-1-thread-3即将到达集合地点3，当前已有1个已经到达，正在等候
	线程pool-1-thread-1即将到达集合地点3，当前已有2个已经到达，正在等候
	线程pool-1-thread-2即将到达集合地点3，当前已有3个已经到达，正在等候
	集合完毕，到达目的地
	集合完毕，到达目的地
	集合完毕，到达目的地
 **/

CountDownLatch工具类:

package edu.java5.util;

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.CyclicBarrier;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CountdownLatchTest {

	public static void main(String[] args) {
		ExecutorService service = Executors.newCachedThreadPool();
		final CountDownLatch cdOrder = new CountDownLatch(1);
		final CountDownLatch cdAnswer = new CountDownLatch(3);		
		for(int i=0;i<3;i++){
			Runnable runnable = new Runnable(){
					public void run(){
					try {
						System.out.println("线程" + Thread.currentThread().getName() + 
								"正准备接受命令");						
						cdOrder.await();
						System.out.println("线程" + Thread.currentThread().getName() + 
						"已接受命令");								
						Thread.sleep((long)(Math.random()*10000));	
						System.out.println("线程" + Thread.currentThread().getName() + 
								"回应命令处理结果");						
						cdAnswer.countDown();						
					} catch (Exception e) {
						e.printStackTrace();
					}				
				}
			};
			service.execute(runnable);
		}		
		try {
			Thread.sleep((long)(Math.random()*10000));
		
			System.out.println("线程" + Thread.currentThread().getName() + 
					"即将发布命令");						
			cdOrder.countDown();
			System.out.println("线程" + Thread.currentThread().getName() + 
			"已发送命令，正在等待结果");	
			cdAnswer.await();
			System.out.println("线程" + Thread.currentThread().getName() + 
			"已收到所有响应结果");	
		} catch (Exception e) {
			e.printStackTrace();
		}				
		service.shutdown();

	}
}
/**
 * 结果：
 *  线程pool-1-thread-1正准备接受命令
	线程pool-1-thread-2正准备接受命令
	线程pool-1-thread-3正准备接受命令
	线程main即将发布命令
	线程main已发送命令，正在等待结果
	线程pool-1-thread-2已接受命令
	线程pool-1-thread-1已接受命令
	线程pool-1-thread-3已接受命令
	线程pool-1-thread-1回应命令处理结果
	线程pool-1-thread-3回应命令处理结果
	线程pool-1-thread-2回应命令处理结果
	线程main已收到所有响应结果
 **/

Exchanger工具类:

package edu.java5.util;

import java.util.concurrent.Exchanger;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class ExchangerTest {
/**
 * 讲解Exchanger的比喻：
 *   好比两个毒贩要进行交易，一手交钱、一手交货，不管谁先来到接头地点后，就处于等待状态了，当另外一方也到达了接头地点（所谓到达接头地点，也就是到到达了准备接头的状态）时，两者的数据就立即交换了，然后就又可以各忙各的了。
 *
 *   exchange方法就相当于两手高高举着待交换物，等待人家前来交换，一旦人家到来（即人家也执行到exchange方法），则两者立马完成数据的交换。
 **/
	public static void main(String[] args) {
		ExecutorService service = Executors.newCachedThreadPool();
		final Exchanger exchanger = new Exchanger();
		service.execute(new Runnable(){
			public void run() {
				try {				
					Thread.sleep((long)(Math.random()*10000));
					String data1 = "zxx";
					System.out.println("线程" + Thread.currentThread().getName() + 
					"正在把数据" + data1 +"换出去");
					String data2 = (String)exchanger.exchange(data1);
					System.out.println("线程" + Thread.currentThread().getName() + 
					"换回的数据为" + data2);
				}catch(Exception e){
					
				}
			}	
		});
		service.execute(new Runnable(){
			public void run() {
				try {				
					Thread.sleep((long)(Math.random()*10000));
					String data1 = "lhm";
					System.out.println("线程" + Thread.currentThread().getName() + 
					"正在把数据" + data1 +"换出去");
					String data2 = (String)exchanger.exchange(data1);
					System.out.println("线程" + Thread.currentThread().getName() + 
					"换回的数据为" + data2);
				}catch(Exception e){
					
				}				
			}	
		});		
	}
}
/**
 * 结果:
	线程pool-1-thread-2正在把数据lhm换出去
	线程pool-1-thread-1正在把数据zxx换出去
	线程pool-1-thread-1换回的数据为lhm
	线程pool-1-thread-2换回的数据为zxx
 **/

xh16319

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
java5中为多线程提供的同步工具类

1、Semaphore实现信号灯 (1)Semaphore可以维护当前访问自身的线程个数，并提供了同步机制。使用Semaphore可以控制同时访问资源的线程个数，例如，实现一个文件允许的并发访问数。 A、 Semaphore实现的功能就类似厕所有5个坑，假如有十个人要上厕所，那么同时能有多少个人去上厕所呢？同时只能有5个人能够占用，当5个人中的任何一个人让开后，
复制链接

扫一扫

专栏目录