JUC 多线程顺序执行

摘要: 小陈、小韦、小罗 三个人打牌，手里各有一张牌，分别是A、B、C三张牌，三人出牌是异步的，怎么保证三人出牌的顺序始终是ABC？

题目

　　小陈、小韦、小罗 三个人打牌，手里各有一张牌，分别是A、B、C三张牌，三人出牌是异步的，怎么保证三人出牌的顺序始终是ABC？

题目分析

　　题目考的是多线程之间的通信，线程通信一般有几种方式：

共享内存

回调函数

管道流

信号量（Semaphore）

　　因为了节省CPU资源当一个人出牌的时候需要保证其他人是阻塞，而不是轮询的去检查是不是该自己出牌了（上面的共享内存、回调函数等方式），另外这个地方也不能用互斥锁，互斥锁对控制超过2个以上线程的顺序执行是比较困难和繁琐的，当然也可以用thread.join() ，但实际情况中一般不会有线程B内部已知线程A的情况。而Semaphore是可以很容易实现这种控制多线程按顺序执行的场景。

实现

Semaphore介绍

　　信号量（Semaphore）：Semaphore实现的功能就类似厕所有5个坑，假如有10个人要上厕所，那么同时只能有多少个人去上厕所呢？同时只能有5个人能够占用，当5个人中 的任何一个人让开后，其中等待的另外5个人中又有一个人可以占用了。另外等待的5个人中可以是随机获得优先机会（不公平），也可以是按照先来后到的顺序获得机会（公平：链表维护的顺序，每次取链表头部Node，Node中保存了Thread），这取决于构造Semaphore对象时传入的参数选项（但其实我理解公平不公平的意义好像不大，因为操作系统线程调用是随机的，所以哪个线程先到还不一定，这个不知道基于什么场景设计的*） 。单个信号量的Semaphore对象可以实现互斥锁的功能，并且可以是由一个线程获得了“锁”，再由另一个线程释放“锁”（这个特性很重要），这可应用于死锁恢复的一些场合，另外Semaphore底层是CAS实现的，无锁，无线程上下文切换消耗，性能高。

Semaphore原理

　　实际上Semaphore的原理比较简单，就是CAS，如果不成功就一直尝试，他是没有锁的，看看源码

final int nonfairTryAcquireShared(int acquires) {
for (;;) {
//当前还有多少个资源可用
int available = getState();
//可用资源减去线程索取，如果少于0说明资源不够 进入下一轮循环，直到资源够
int remaining = available - acquires;
if (remaining < 0 ||
compareAndSetState(available, remaining))//CAS原子性操作
return remaining;
}
}

代码实现

public class SemaphoreTest2 {

private final Semaphore semaphoreA = new Semaphore(1);
private final Semaphore semaphoreB = new Semaphore(1);
private final Semaphore semaphoreC = new Semaphore(1);

public void start() throws InterruptedException {

//ABC线程启动之前 获取SemaphoreB的1个资源，保证线程A最先执行
semaphoreB.acquire();
//ABC线程启动之前 获取SemaphoreC的1个资源，保证线程A最先执行
semaphoreC.acquire();

Thread a=new Thread(new Runnable(){
@Override
public void run() {
while (true){
try {
semaphoreA.acquire();
System.out.print("A");
//之前说的特性：可以在ThreadA释放ThreadB的Semaphore资源， 下同
semaphoreB.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});

Thread b=new Thread(new Runnable(){
@Override
public void run() {
while (true){
try {
semaphoreB.acquire();
System.out.print("B");
semaphoreC.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});

Thread c=new Thread(new Runnable(){
@Override
public void run() {
while (true){
try {
semaphoreC.acquire();
System.out.println("C");
semaphoreA.release();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
});
c.start();
b.start();
a.start();
}

public static final void main(String arsg[]) throws InterruptedException {
SemaphoreTest2 semaphoreTest2=new SemaphoreTest2();
semaphoreTest2.start();
}
}

Semaphore总结

　　Semaphore常用的场景：

高性能的互斥锁实现（本题有涉及）

限制访问公共资源的线程个数，如只有5个资源，那么同时执行的线程就只能是5个

控制多线程执行流程控制，如：主线程等待所有异步线程执行完毕后再执行、或者多个异步线程的执行顺序（类似本题目）

以上是我想到的三个场景，赘述不对地方欢迎拍砖。

注：版权所有转载请注明出处http://my.oschina.net/u/926166/blog/532338