java线程——信号量（Semaphore）+障栅（CyclicBarrier）

【0】README

0.1）以下内容转自网络，旨在理清 “java线程——信号量（Semaphore）+障栅（CyclicBarrier）”的相关知识

---

【1】信号量

1.1）信号量定义：从概念上讲，一个信号量管理许多的许可证。为了通过信号量，线程通过调用 acquire 请求许可；
1.2）其实没有实际的许可对象， 信号量仅仅是维护了一个计数；
1.3）看个荔枝：转自 http://www.cnblogs.com/whgw/archive/2011/09/29/2195555.html

• 1.3.1） Semaphore当前在多线程环境下被扩放使用，操作系统的信号量是个很重要的概念，在进程控制方面都有应用。Java 并发库 的Semaphore 可以很轻松完成信号量控制，Semaphore可以控制某个资源可被同时访问的个数，通过 acquire() 获取一个许可，如果没有就等待，而 release() 释放一个许可。比如在Windows下可以设置共享文件的最大客户端访问个数。
• 1.3.2）荔枝说明： Semaphore实现的功能就类似厕所有5个坑，假如有10个人要上厕所，那么同时只能有多少个人去上厕所呢？ 同时只能有5个人能够占用，当5个人中 的任何一个人让开后，其中等待的另外5个人中又有一个人可以占用了。另外等待的5个人中可以是随机获得优先机会，也可以是按照先来后到的顺序获得机会，这取决于构造Semaphore对象时传入的参数选项。单个信号量的Semaphore对象可以实现互斥锁的功能，并且可以是由一个线程获得了“锁”，再由另一个线程释放“锁”，这可应用于死锁恢复的一些场合。
• 1.3.3）Semaphore维护了当前访问的个数，提供同步机制，控制同时访问的个数。 在数据结构中链表可以保存“无限”的节点，用Semaphore可以实现有限大小的链表。另外重入锁 ReentrantLock 也可以实现该功能，但实现上要复杂些。

1.4）下面的Demo中申明了一个只有5个许可的Semaphore，而有10个线程要访问这个资源，通过acquire()和release()获取和释放访问许可。

• for full source code, please visit ： https://github.com/pacosonTang/core-java-volume/blob/master/chapter14/SemaphoreTest.java
  

• source code at a glance :

package com.corejava.chapter14_6;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import static java.lang.System.*;

public class SemaphoreTest
{
    public static void main(String[] args)
    {
        // thread pool
        ExecutorService exec = Executors.newCachedThreadPool();
        // there must be 5 threads accessing certain source
        final Semaphore semaphore = new Semaphore(5);
        for (int i = 0; i < 10; i++)
        {
            final int num = i;
            Runnable run = new Runnable() // create 10 threads circularly
            {
                @Override
                public void run()
                {
                    try
                    {
                        semaphore.acquire();// acquire permission
                        out.println("accessing " + num);
                        Thread.sleep((long)(Math.random()*10000));
                        semaphore.release(); // release permission
                        out.println("semaphore.availablePermits = " 
                        + semaphore.availablePermits());
                    }catch(InterruptedException e)
                    {
                        e.printStackTrace();
                    }
                }
            };
            exec.execute(run);// thread's startup
        }
        exec.shutdown(); // shutdown all of threads
    }
}

---

【2】障栅

2.1）定义： CyclicBarrier 类实现了一个集结点 称为障栅；

• 2.1.1）障栅的作用：考虑大量线程运行在一次计算的不同部分的情形： 当所有部分都准备好时， 需要吧结果组合到一起， 当一个线程完成了它的那部分任务后， 我们让它运行到障栅处。 一旦所有的线程都到达了这个 障栅， 障栅就撤销了， 线程就可以继续运行了了；

• step1）构造一个障栅，并给出参与的线程数：

CyclicBarrier cyclicBarrier = new CyclicBarrier(2, new Runnable()

• step2） 每个线程做一些工作， 完成后再障栅上调用 await（）方法

public void run()
 {
  arr[id] = new Random().nextInt(100);
  try
  {
   out.println(id + " starts to have a rest!");
   cyclicBarrier.await();
   out.println(id + "wake up!");
  } catch (Exception e)
  {
   e.printStackTrace();
  }

• step3） 如果任何一个在 障栅上等待的线程离开了障栅， 那么障栅就被破坏了；
• step4）可以提供一个可选的 障栅 动作（Barrier Action）， 当所有线程到达障栅的时候就会执行这个工作：

Runnable barrierAction = ...
CyclicBarrier cyclicBarrier = new CyclicBarrier(nthreds, barrienAction)
CyclicBarrier cyclicBarrier = new CyclicBarrier(2, new Runnable()

• step5） 障栅被称为是循环的， 因为可以在所有等待线程被释放后被重用。 在这一点上， 有别于 CountDownLatch， CountDownLatch 只能被使用一次；

2.2）看个荔枝： 转自 http://my.oschina.net/summerpxy/blog/189799

• 2.2.1）CyclicBarrier称为障栅，这个类有什么作用呢？ 这个类是用来同步线程用的。以小黑车为例（就是盘踞在地铁口的黑出租），一般小黑车是坐4个人，只有4个人都满了之后小黑车才会走，那么如果你是第一个来的，进车坐下，等第二个人来。第二个人来了，等第三个人，如此直到所有的4个人满了之后小黑车才开车。那么这个类也是一样的。

  • 第一个线程：运行到障栅出，等待第二个线程到达。
  • 第二个线程：运行到障栅出，等待第三个线程到达。
  • 第三个线程：运行到障栅出，等待第四个线程到达。
  • 第四个线程：运行到障栅出，障栅解除，所有线程都开始执行。
• 2.2.2）荔枝代码：下面是一个demo，arr[0]和arr[1]的赋值是两个线程完成的，当两个线程的赋值结束之后才会得到arr[2]的值：
  
  • for full source code , please visit https://github.com/pacosonTang/core-java-volume/blob/master/chapter14/CyclicBarrierTest.java

• source code at a glance :

package com.corejava.chapter14_6;

import java.util.Random;
import java.util.concurrent.CyclicBarrier;
import static java.lang.System.*;

public class CyclicBarrierTest
{
    public static void main(String[] args)
    {
        int[] arr = new int[3];
        //可以提供一个可选的 障栅 动作（Barrier Action）， 当所有线程到达障栅的时候就会执行这个工作
        //CyclicBarrier cyclicBarrier = new CyclicBarrier(nthreds, barrienAction)
        CyclicBarrier cyclicBarrier = new CyclicBarrier(2, new Runnable()
        {
            @Override
            public void run()
            {
                arr[2] = arr[0] + arr[1];
                for (int i = 0; i < arr.length; i++)
                    out.println("arr[" + i +"] = " + arr[i]);
            }
        });

        new Thread(new MyCyclicBarrier(1, arr, cyclicBarrier)).start();
        new Thread(new MyCyclicBarrier(0, arr, cyclicBarrier)).start();
    }
}

class MyCyclicBarrier implements Runnable
{
    int id;
    int[] arr;
    CyclicBarrier cyclicBarrier;

    public MyCyclicBarrier(int id, int[] arr, CyclicBarrier barrier)
    {
        this.id = id;
        this.arr = arr;
        this.cyclicBarrier = barrier;
    }

    @Override
    public void run()
    {
        arr[id] = new Random().nextInt(100);
        try
        {
            out.println(id + " starts to have a rest!");
            cyclicBarrier.await();
            out.println(id + " wake up!");
        } catch (Exception e)
        {
            e.printStackTrace();
        }
    }

}