线程高级应用-心得6-java5线程并发库中同步工具类（synchronizers），新知识大用途

最新推荐文章于 2017-07-24 11:27:44 发布

y_keven

最新推荐文章于 2017-07-24 11:27:44 发布

阅读量2k

点赞数 1

分类专栏： JAVA高级 J2EE 架构设计 java线程与并发库高级应用文章标签： java Java JAVA java java5新技术杨凯专属频道线程并发语言

本文链接：https://blog.csdn.net/yangkai_hudong/article/details/8579386

版权

J2EE 同时被 3 个专栏收录

120 篇文章 0 订阅

订阅专栏

JAVA高级

107 篇文章 0 订阅

订阅专栏

架构设计

9 篇文章 0 订阅

订阅专栏

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){
					
				}
			}
		});

	}

}

y_keven

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
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.Semap
复制链接

扫一扫