线程高级运用-心得6-java5线程并发库中同步工具类（synchronizers），新知识大用途
线程高级应用-心得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){
}
}
});
}
}