JUC 多线程顺序执行

题目

　　小陈、小韦、小罗 三个人打牌，手里各有一张牌，分别是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