Java中的信号量Semaphore

1、信号量概念

   信号量(Semaphore)，有时被称为信号灯，是在多线程环境下使用的一种设施，是可以用来保证两个或多个关键代码段不被并发调用。在进入一个关键代码段之前，线程必须获取一个信号量；一旦该关键代码段完成了，那么该线程必须释放信号量。其它想进入该关键代码段的线程必须等待直到第一个线程释放信号量。为了完成这个过程，需要创建一个信号量VI，然后将Acquire Semaphore VI以及Release Semaphore VI分别放置在每个关键代码段的首末端。确认这些信号量VI引用的是初始创建的信号量。

这是百度百科中对信号量的描述，学过操作系统的对信号量并不陌生，Java中用Semaphore类表示信号量，Semaphore维护了当前访问的个数，提供同步机制，控制同时访问的个数。

2、Semaphore的主要方法：

void acquire():从此信号量获取一个许可，在提供一个许可前一直将线程阻塞，否则线程被中断。
void release():释放一个许可，将其返回给信号量。
int availablePermits():返回此信号量中当前可用的许可数。
boolean hasQueuedThreads():查询是否有线程正在等待获取。

3、构造函数

public Semaphore(int permits,boolean fair) 

permits:初始化可用的许可数目。 fair: 若该信号量保证在征用时按FIFO的顺序授予许可，则为true，否则为false

4、使用示例

package com.example.sy.a20170606;

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.util.Log;
import android.view.View;
import android.widget.Button;
import android.widget.TextView;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;

public class MainActivity extends AppCompatActivity {

    private Button btn;
    private Semaphore semaphore;
    private ExecutorService newCachedThreadPool;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        btn = (Button) findViewById(R.id.btn);
        newCachedThreadPool = Executors.newCachedThreadPool();//线程池
        semaphore = new Semaphore(3);

        btn.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                gogogo();
            }
        });
    }

    private void gogogo() {

        for (int i = 0; i < 10; i++) {
            newCachedThreadPool.execute(new Runnable() {
                @Override
                public void run() {
                    try {
                        semaphore.acquire();
                        Log.e("semaphore", "线程：" + Thread.currentThread().getName() + " 正在访问");
                        Thread.sleep(3000);//模拟访问操作
                        semaphore.release();
                        Log.e("semaphore", "线程：" + Thread.currentThread().getName() + " 结束访问");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            });
        }
        newCachedThreadPool.shutdown();
    }
}

代码很简单，初始化三个信号量，点击按钮执行gogogo方法，循环十次从线程池取线程执行打印日志。

打印日志结果：

线程：pool-1-thread-1 正在访问
线程：pool-1-thread-2 正在访问
线程：pool-1-thread-5 正在访问
线程：pool-1-thread-1 结束访问
线程：pool-1-thread-4 正在访问
线程：pool-1-thread-3 正在访问
线程：pool-1-thread-2 结束访问
线程：pool-1-thread-6 正在访问
线程：pool-1-thread-5 结束访问
线程：pool-1-thread-4 结束访问
线程：pool-1-thread-7 正在访问
线程：pool-1-thread-3 结束访问
线程：pool-1-thread-8 正在访问
线程：pool-1-thread-6 结束访问
线程：pool-1-thread-9 正在访问
线程：pool-1-thread-7 结束访问
线程：pool-1-thread-10 正在访问
线程：pool-1-thread-8 结束访问
线程：pool-1-thread-9 结束访问
线程：pool-1-thread-10 结束访问

可以从日志清楚地看到，最多有三个线程并发执行，即同时最多有三个线程访问公共资源。

参考资料：
Java并发包中Semaphore的工作原理、源码分析及使用示例 - nullzx - 博客园
http://www.cnblogs.com/nullzx/p/5270233.html
Semaphore的使用 - 残剑_ - 博客园
http://www.cnblogs.com/liuling/p/2013-8-20-03.html