同步器之Semaphore

一个计数信号量。从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个

acquire()

，然后再获取该许可。每个

release()

添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，

Semaphore

只对可用许可的号码进行计数，并采取相应的行动。

Semaphore 通常用于限制可以访问某些资源（物理或逻辑的）的线程数目。例如，下面的类使用信号量控制对内容池的访问：

import java.util.concurrent.Semaphore;

public class PoolSemaphoreDemo {
    private static final int MAX_AVAILABLE = 5;
    private final Semaphore available = new Semaphore(MAX_AVAILABLE, true);

    public static void main(String[] args) {
        final PoolSemaphoreDemo pool = new PoolSemaphoreDemo();
        Runnable runner = new Runnable() {
            public void run() {
                try {
                    Object o;
                    o = pool.getItem();

                    Thread.sleep(1000);// 表示该线程睡眠1秒钟，即改线程不去竞争cpu处理时间1秒钟

                    pool.putItem(o);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        // 将上述线程重复执行10次
        for (int i = 0; i < 10; i++) {
            Thread t = new Thread(runner, "t" + i);
            t.start();
        }
    }

    /**
     * 从字符串池中取得最近一个可用的字符串资源，同时将标志位池中的状态设为true，表示有线程正在使用。
     *
     * @return
     * @throws InterruptedException
     */
    public Object getItem() throws InterruptedException {
        System.out.println("线程：" + Thread.currentThread().getName()
                + "开始从字符串资源池中取数据");
        available.acquire();
        return getNextAvailableItem();
    }

    /**
     * 将x对应的标志位池的状态修改为false，然后释放改字符串资源供其他线程读取
     *
     * @param x
     */
    public void putItem(Object x) {
        if (markAsUnused(x)) {
            available.release();
            System.out.println("线程：" + Thread.currentThread().getName()
                    + "已经释放资源");
        }
    }

    // 需要循环取的字符串池
    protected Object[] items = { "AAA", "BBB", "CCC", "DDD", "EEE" };
    // 字符串池对应的标志位池，如果为true表示正在使用，其他线程不可用。如果为false，则表示其他线程可以用
    protected boolean[] used = new boolean[MAX_AVAILABLE];

    /**
     * 根据标志位数组得到items中有效的字符串
     *
     * @return
     */
    protected synchronized Object getNextAvailableItem() {
        for (int i = 0; i < MAX_AVAILABLE; ++i) {
            if (!used[i]) {
                used[i] = true;
                System.out.println("线程：" + Thread.currentThread().getName()
                        + "从字符串池中取得资源：" + items[i]);
                return items[i];
            }
        }
        return null;
    }

    /**
     * 根据item将对应位置的标志位的值改为false
     *
     * @param item
     * @return
     */
    protected synchronized boolean markAsUnused(Object item) {
        for (int i = 0; i < MAX_AVAILABLE; ++i) {
            if (item == items[i]) {
                if (used[i]) {
                    used[i] = false;
                    System.out.println("线程：" + Thread.currentThread().getName()
                            + "开始向字符串池中放入资源：" + items[i]);
                    return true;
                } else
                    return false;
            }
        }
        return false;
    }

}      

输出结果:

线程：t0开始从字符串资源池中取数据
线程：t2开始从字符串资源池中取数据
线程：t1开始从字符串资源池中取数据
线程：t0从字符串池中取得资源：AAA
线程：t1从字符串池中取得资源：BBB
线程：t2从字符串池中取得资源：CCC
线程：t3开始从字符串资源池中取数据
线程：t3从字符串池中取得资源：DDD
线程：t4开始从字符串资源池中取数据
线程：t5开始从字符串资源池中取数据
线程：t4从字符串池中取得资源：EEE
线程：t6开始从字符串资源池中取数据
线程：t7开始从字符串资源池中取数据
线程：t8开始从字符串资源池中取数据
线程：t9开始从字符串资源池中取数据
线程：t2开始向字符串池中放入资源：CCC
线程：t2已经释放资源
线程：t4开始向字符串池中放入资源：EEE
线程：t4已经释放资源
线程：t3开始向字符串池中放入资源：DDD
线程：t3已经释放资源
线程：t1开始向字符串池中放入资源：BBB
线程：t1已经释放资源
线程：t0开始向字符串池中放入资源：AAA
线程：t0已经释放资源
线程：t8从字符串池中取得资源：AAA
线程：t7从字符串池中取得资源：BBB
线程：t6从字符串池中取得资源：CCC
线程：t5从字符串池中取得资源：DDD
线程：t9从字符串池中取得资源：EEE
线程：t7开始向字符串池中放入资源：BBB
线程：t7已经释放资源
线程：t5开始向字符串池中放入资源：DDD
线程：t5已经释放资源
线程：t6开始向字符串池中放入资源：CCC
线程：t6已经释放资源
线程：t8开始向字符串池中放入资源：AAA
线程：t8已经释放资源
线程：t9开始向字符串池中放入资源：EEE
线程：t9已经释放资源      

获得一项前，每个线程必须从信号量获取许可，从而保证可以使用该项。该线程结束后，将项返回到池中并将许可返回到该信号量，从而允许其他线程获取该项。注意，调用

acquire()

时无法保持同步锁，因为这会阻止将项返回到池中。信号量封装所需的同步，以限制对池的访问，这同维持该池本身一致性所需的同步是分开的。

将信号量初始化为 1，使得它在使用时最多只有一个可用的许可，从而可用作一个相互排斥的锁。这通常也称为二进制信号量，因为它只能有两种状态：一个可用的许可，或零个可用的许可。按此方式使用时，二进制信号量具有某种属性（与很多

Lock

实现不同），即可以由线程释放“锁”，而不是由所有者（因为信号量没有所有权的概念）。在某些专门的上下文（如死锁恢复）中这会很有用。

此类的构造方法可选地接受一个公平 参数。当设置为 false 时，此类不对线程获取许可的顺序做任何保证。特别地，闯入 是允许的，也就是说可以在已经等待的线程前为调用

acquire()

的线程分配一个许可，从逻辑上说，就是新线程将自己置于等待线程队列的头部。当公平设置为 true 时，信号量保证对于任何调用

获取

方法的线程而言，都按照处理它们调用这些方法的顺序（即先进先出；FIFO）来选择线程、获得许可。注意，FIFO 排序必然应用到这些方法内的指定内部执行点。所以，可能某个线程先于另一个线程调用了

acquire

，但是却在该线程之后到达排序点，并且从方法返回时也类似。还要注意，非同步的

tryAcquire

方法不使用公平设置，而是使用任意可用的许可。

通常，应该将用于控制资源访问的信号量初始化为公平的，以确保所有线程都可访问资源。为其他的种类的同步控制使用信号量时，非公平排序的吞吐量优势通常要比公平考虑更为重要。

此类还提供便捷的方法来同时

acquire

和

释放

多个许可。小心，在未将公平设置为 true 时使用这些方法会增加不确定延期的风险。

内存一致性效果：线程中调用“释放”方法（比如

release()

）之前的操作 happen-before 另一线程中紧跟在成功的“获取”方法（比如

acquire()

）之后的操作。

转载于:https://www.cnblogs.com/XL-Liang/archive/2012/06/14/2549220.html