MyException - 我的异常网
当前位置:我的异常网» 编程 » 线程高级运用-心得6-java5线程并发库中同步工具类(

线程高级运用-心得6-java5线程并发库中同步工具类(synchronizers),新知识大用途

www.MyException.Cn  网友分享于:2013-02-20  浏览:0次
线程高级应用-心得6-java5线程并发库中同步工具类(synchronizers),新知识大用途

1.新知识普及

2. Semaphore工具类的使用案例
package com.java5.thread.newSkill;

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

/**
 * Semaphore工具类的使用案例
 * 跟互斥锁有点相似,只是互斥锁只有一把,信号灯可以有多个
 * 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() {
				
				@Override
				public void run() {
					try {
						//acquire:获得;下面方法是获取信号灯
						sp.acquire();
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
					//availablePermits():可以获得的许可
					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-1 即将离开!
线程 pool-1-thread-1 离开,当前已有 0 个并发!
线程 pool-1-thread-1 进入,当前已有 1 个并发!
线程 pool-1-thread-1 即将离开!
线程 pool-1-thread-1 离开,当前已有 0 个并发!
线程 pool-1-thread-1 进入,当前已有 1 个并发!
线程 pool-1-thread-3 进入,当前已有 2 个并发!
线程 pool-1-thread-1 即将离开!
线程 pool-1-thread-1 离开,当前已有 1 个并发!
线程 pool-1-thread-3 即将离开!
线程 pool-1-thread-3 离开,当前已有 0 个并发!
线程 pool-1-thread-3 进入,当前已有 1 个并发!
线程 pool-1-thread-1 进入,当前已有 2 个并发!
线程 pool-1-thread-3 即将离开!
线程 pool-1-thread-3 离开,当前已有 1 个并发!
线程 pool-1-thread-1 即将离开!
线程 pool-1-thread-1 离开,当前已有 0 个并发!
线程 pool-1-thread-1 进入,当前已有 1 个并发!
线程 pool-1-thread-5 进入,当前已有 2 个并发!
线程 pool-1-thread-1 即将离开!
线程 pool-1-thread-1 离开,当前已有 1 个并发!
线程 pool-1-thread-5 即将离开!
线程 pool-1-thread-5 离开,当前已有 0 个并发!
线程 pool-1-thread-2 进入,当前已有 1 个并发!
线程 pool-1-thread-2 即将离开!
线程 pool-1-thread-2 离开,当前已有 0 个并发!
线程 pool-1-thread-4 进入,当前已有 1 个并发!
线程 pool-1-thread-4 即将离开!
线程 pool-1-thread-4 离开,当前已有 0 个并发!

 */
3. CyclicBarrier工具类的使用案例
package com.java5.thread.newSkill;

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

/**
 * CyclicBarrier工具类的使用案例
 *   应用场景:各个线程彼此等待,到齐后集体出发
 * cyclic:循环的,周期性的
 * barrier:障碍物,屏障  
 */
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() {
				
				@Override
				public void run() {
					try {
						Thread.sleep((long)Math.random()*10000);
						//cb.getNumberWaiting()+1;是因为该方法获取的数量是从0开始的
						System.out.println("线程 "+ Thread.currentThread().getName()+" 即将到达集合地点1,当前已有 "+(cb.getNumberWaiting()+1)+"已经到达;"+(cb.getNumberWaiting()==2?"都到齐了,继续走啊!":"正在等候!"));
						//想在什么地方集合就在什么地方await()等待
						cb.await();
						
						Thread.sleep((long)Math.random()*10000);
						System.out.println("线程 "+ Thread.currentThread().getName()+" 即将到达集合地点2,当前已有 "+(cb.getNumberWaiting()+1)+"已经到达;"+(cb.getNumberWaiting()==2?"都到齐了,继续走啊!":"正在等候!"));
						
						cb.await();
						
						Thread.sleep((long)Math.random()*10000);
						System.out.println("线程 "+ Thread.currentThread().getName()+" 即将到达集合地点3,当前已有 "+(cb.getNumberWaiting()+1)+"已经到达;"+(cb.getNumberWaiting()==2?"都到齐了,继续走啊!":"正在等候!"));
					
						cb.await();
					} 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已经到达;都到齐了,继续走啊!
线程 pool-1-thread-2 即将到达集合地点2,当前已有 1已经到达;正在等候!
线程 pool-1-thread-1 即将到达集合地点2,当前已有 2已经到达;正在等候!
线程 pool-1-thread-3 即将到达集合地点2,当前已有 3已经到达;都到齐了,继续走啊!
线程 pool-1-thread-3 即将到达集合地点3,当前已有 1已经到达;正在等候!
线程 pool-1-thread-2 即将到达集合地点3,当前已有 2已经到达;正在等候!
线程 pool-1-thread-1 即将到达集合地点3,当前已有 3已经到达;都到齐了,继续走啊!
*/

4. CountDownLacth工具类的使用案例
package com.java5.thread.newSkill;

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

/**
 * CountDownLacth工具类的使用案例
 * 犹如倒计时计数器
 * latch:门闩,闩门
 * 应用场景:运动员比赛;裁判计时!一款比赛小游戏
 * 下面例子:三个线程好比三个运动员,主线程好比一个裁判
 */
public class CountDownLatchTest {

	public static void main(String[] args) {

		ExecutorService service = Executors.newCachedThreadPool();
		
		//设置一个数量为1的计时器
		final CountDownLatch cdOrder = new CountDownLatch(1);
		//设置一个数量为3的计时器
		final CountDownLatch cdAnswer = new CountDownLatch(3);
		for(int i=0;i<3;i++){
			Runnable runnable= new Runnable() {
				
				@Override
				public void run() {
					try {
						System.out.println("线程 "+ Thread.currentThread().getName()+"正准备接受命令!");
						
						/*开启三个线程,都在这里等待;
						 * 如何开始下一步呢!?就是再开启一个主线程来用countDown()方法;
						 * 来进行减数,减到0就可以进行下一步程序
						 */
						cdOrder.await();
						
						System.out.println("线程 "+ Thread.currentThread().getName()+"已接受命令!");
						Thread.sleep((long)Math.random()*10000);
						System.out.println("线程 "+ Thread.currentThread().getName()+"回应命令处理结果!");
						
						//countDown();方法就是将计数器身上的计数减1
						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()+"已发送命令,正在等待结果!");

			cdOrder.await();
			
			System.out.println("线程 "+ Thread.currentThread().getName()+"已收到所有响应结果!");
			
			cdAnswer.countDown();
		
		} catch (Exception e) {
			e.printStackTrace();
		}
		service.shutdown();
	}

}
5. Exchanger工具类的使用案例
package com.java5.thread.newSkill;

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

/**
 * Exchanger工具类的使用案例
 * 应用场景:交易性应用或游戏
 *   两个人碰在一起,交换彼此的数据
 */
public class ExchangerTest {

	public static void main(String[] args) {
		
		ExecutorService service = Executors.newCachedThreadPool();
		final Exchanger exchanger = new Exchanger();
		service.execute(new Runnable() {
			
			@Override
			public void run() {
				try{
					
					String data1 = "杨凯";
					System.out.println("线程 "+Thread.currentThread().getName()+" 正在把数据: "+data1+" 换出去!");
					
					Thread.sleep((long)Math.random()*10000);
					
					String data2 = (String) exchanger.exchange(data1);
					System.out.println("线程 "+Thread.currentThread().getName()+" 换回的数据为:"+data2);
				}catch(Exception e){
					
				}
			}
		});
		service.execute(new Runnable() {
			
			@Override
			public void run() {
				try{
					
					String data1 = "杨旋";
					System.out.println("线程 "+Thread.currentThread().getName()+" 正在把数据: "+data1+" 换出去!");
					
					Thread.sleep((long)Math.random()*10000);
					
					String data2 = (String) exchanger.exchange(data1);
					System.out.println("线程 "+Thread.currentThread().getName()+" 换回的数据为:"+data2);
				}catch(Exception e){
					
				}
			}
		});

	}

}


 

文章评论

软件开发程序错误异常ExceptionCopyright © 2009-2015 MyException 版权所有