Java多线程系列--“JUC锁”11之 Semaphore信号量的原理和示例

 

概要

本章，我们对JUC包中的信号量Semaphore进行学习。内容包括：
Semaphore简介
Semaphore数据结构
Semaphore源码分析(基于JDK1.7.0_40)
Semaphore示例

转载请注明出处：http://www.cnblogs.com/skywang12345/p/3534050.html

 

Semaphore简介

Semaphore是一个计数信号量，它的本质是一个"共享锁"。

信号量维护了一个信号量许可集。线程可以通过调用acquire()来获取信号量的许可；当信号量中有可用的许可时，线程能获取该许可；否则线程必须等待，直到有可用的许可为止。 线程可以通过release()来释放它所持有的信号量许可。

Semaphore的函数列表

// 创建具有给定的许可数和非公平的公平设置的 Semaphore。

Semaphore(int permits)

// 创建具有给定的许可数和给定的公平设置的 Semaphore。

Semaphore(int permits, boolean fair)



// 从此信号量获取一个许可，在提供一个许可前一直将线程阻塞，否则线程被中断。

void acquire()

// 从此信号量获取给定数目的许可，在提供这些许可前一直将线程阻塞，或者线程已被中断。

void acquire(int permits)

// 从此信号量中获取许可，在有可用的许可前将其阻塞。

void acquireUninterruptibly()

// 从此信号量获取给定数目的许可，在提供这些许可前一直将线程阻塞。

void acquireUninterruptibly(int permits)

// 返回此信号量中当前可用的许可数。

int availablePermits()

// 获取并返回立即可用的所有许可。

int drainPermits()

// 返回一个 collection，包含可能等待获取的线程。

protected Collection<Thread> getQueuedThreads()

// 返回正在等待获取的线程的估计数目。

int getQueueLength()

// 查询是否有线程正在等待获取。

boolean hasQueuedThreads()

// 如果此信号量的公平设置为 true，则返回 true。

boolean isFair()

// 根据指定的缩减量减小可用许可的数目。

protected void reducePermits(int reduction)

// 释放一个许可，将其返回给信号量。

void release()

// 释放给定数目的许可，将其返回到信号量。

void release(int permits)

// 返回标识此信号量的字符串，以及信号量的状态。

String toString()

// 仅在调用时此信号量存在一个可用许可，才从信号量获取许可。

boolean tryAcquire()

// 仅在调用时此信号量中有给定数目的许可时，才从此信号量中获取这些许可。

boolean tryAcquire(int permits)

// 如果在给定的等待时间内此信号量有可用的所有许可，并且当前线程未被中断，则从此信号量获取给定数目的许可。

boolean tryAcquire(int permits, long timeout, TimeUnit unit)

// 如果在给定的等待时间内，此信号量有可用的许可并且当前线程未被中断，则从此信号量获取一个许可。

boolean tryAcquire(long timeout, TimeUnit unit)

 

Semaphore数据结构

Semaphore的UML类图如下：

从图中可以看出：
(01) 和"ReentrantLock"一样，Semaphore也包含了sync对象，sync是Sync类型；而且，Sync是一个继承于AQS的抽象类。
(02) Sync包括两个子类："公平信号量"FairSync 和 "非公平信号量"NonfairSync。sync是"FairSync的实例"，或者"NonfairSync的实例"；默认情况下，sync是NonfairSync(即，默认是非公平信号量)。

 

Semaphore源码分析(基于JDK1.7.0_40)

Semaphore完整源码(基于JDK1.7.0_40)

/*

 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 *

 */



/*

 *

 *

 *

 *

 *

 * Written by Doug Lea with assistance from members of JCP JSR-166

 * Expert Group and released to the public domain, as explained at

 * http://creativecommons.org/publicdomain/zero/1.0/

 */



package java.util.concurrent;

import java.util.*;

import java.util.concurrent.locks.*;

import java.util.concurrent.atomic.*;



/**

 * A counting semaphore.  Conceptually, a semaphore maintains a set of

 * permits.  Each {@link #acquire} blocks if necessary until a permit is

 * available, and then takes it.  Each {@link #release} adds a permit,

 * potentially releasing a blocking acquirer.

 * However, no actual permit objects are used; the {@code Semaphore} just

 * keeps a count of the number available and acts accordingly.

 *

 * <p>Semaphores are often used to restrict the number of threads than can

 * access some (physical or logical) resource. For example, here is

 * a class that uses a semaphore to control access to a pool of items:

 * <pre>

 * class Pool {

 *   private static final int MAX_AVAILABLE = 100;

 *   private final Semaphore available = new Semaphore(MAX_AVAILABLE, true);

 *

 *   public Object getItem() throws InterruptedException {

 *     available.acquire();

 *     return getNextAvailableItem();

 *   }

 *

 *   public void putItem(Object x) {

 *     if (markAsUnused(x))

 *       available.release();

 *   }

 *

 *   // Not a particularly efficient data structure; just for demo

 *

 *   protected Object[] items = ... whatever kinds of items being managed

 *   protected boolean[] used = new boolean[MAX_AVAILABLE];

 *

 *   protected synchronized Object getNextAvailableItem() {

 *     for (int i = 0; i < MAX_AVAILABLE; ++i) {

 *       if (!used[i]) {

 *          used[i] = true;

 *          return items[i];

 *       }

 *     }

 *     return null; // not reached

 *   }

 *

 *   protected synchronized boolean markAsUnused(Object item) {

 *     for (int i = 0; i < MAX_AVAILABLE; ++i) {

 *       if (item == items[i]) {

 *          if (used[i]) {

 *            used[i] = false;

 *            return true;

 *          } else

 *            return false;

 *       }

 *     }

 *     return false;

 *   }

 *

 * }

 * </pre>

 *

 * <p>Before obtaining an item each thread must acquire a permit from

 * the semaphore, guaranteeing that an item is available for use. When

 * the thread has finished with the item it is returned back to the

 * pool and a permit is returned to the semaphore, allowing another

 * thread to acquire that item.  Note that no synchronization lock is

 * held when {@link #acquire} is called as that would prevent an item

 * from being returned to the pool.  The semaphore encapsulates the

 * synchronization needed to restrict access to the pool, separately

 * from any synchronization needed to maintain the consistency of the

 * pool itself.

 *

 * <p>A semaphore initialized to one, and which is used such that it

 * only has at most one permit available, can serve as a mutual

 * exclusion lock.  This is more commonly known as a <em>binary

 * semaphore</em>, because it only has two states: one permit

 * available, or zero permits available.  When used in this way, the

 * binary semaphore has the property (unlike many {@link Lock}

 * implementations), that the &quot;lock&quot; can be released by a

 * thread other than the owner (as semaphores have no notion of

 * ownership).  This can be useful in some specialized contexts, such

 * as deadlock recovery.

 *

 * <p> The constructor for this class optionally accepts a

 * <em>fairness</em> parameter. When set false, this class makes no

 * guarantees about the order in which threads acquire permits. In

 * particular, <em>barging</em> is permitted, that is, a thread

 * invoking {@link #acquire} can be allocated a permit ahead of a

 * thread that has been waiting - logically the new thread places itself at

 * the head of the queue of waiting threads. When fairness is set true, the

 * semaphore guarantees that threads invoking any of the {@link

 * #acquire() acquire} methods are selected to obtain permits in the order in

 * which their invocation of those methods was processed

 * (first-in-first-out; FIFO). Note that FIFO ordering necessarily

 * applies to specific internal points of execution within these

 * methods.  So, it is possible for one thread to invoke

 * {@code acquire} before another, but reach the ordering point after

 * the other, and similarly upon return from the method.

 * Also note that the untimed {@link #tryAcquire() tryAcquire} methods do not

 * honor the fairness setting, but will take any permits that are

 * available.

 *

 * <p>Generally, semaphores used to control resource access should be

 * initialized as fair, to ensure that no thread is starved out from

 * accessing a resource. When using semaphores for other kinds of

 * synchronization control, the throughput advantages of non-fair

 * ordering often outweigh fairness considerations.

 *

 * <p>This class also provides convenience methods to {@link

 * #acquire(int) acquire} and {@link #release(int) release} multiple

 * permits at a time.  Beware of the increased risk of indefinite

 * postponement when these methods are used without fairness set true.

 *

 * <p>Memory consistency effects: Actions in a thread prior to calling

 * a "release" method such as {@code release()}

 * <a href="package-summary.html#MemoryVisibility"><i>happen-before</i></a>

 * actions following a successful "acquire" method such as {@code acquire()}

 * in another thread.

 *

 * @since 1.5

 * @author Doug Lea

 *

 */



public class Semaphore implements java.io.Serializable {

    private static final long serialVersionUID = -3222578661600680210L;

    /** All mechanics via AbstractQueuedSynchronizer subclass */

    private final Sync sync;



    /**

     * Synchronization implementation for semaphore.  Uses AQS state

     * to represent permits. Subclassed into fair and nonfair

     * versions.

     */

    abstract static class Sync extends AbstractQueuedSynchronizer {

        private static final long serialVersionUID = 1192457210091910933L;



        Sync(int permits) {

            setState(permits);

        }



        final int getPermits() {

            return getState();

        }



        final int nonfairTryAcquireShared(int acquires) {

            for (;;) {

                int available = getState();

                int remaining = available - acquires;

                if (remaining < 0 ||

                    compareAndSetState(available, remaining))

                    return remaining;

            }

        }



        protected final boolean tryReleaseShared(int releases) {

            for (;;) {

                int current = getState();

                int next = current + releases;

                if (next < current) // overflow

                    throw new Error("Maximum permit count exceeded");

                if (compareAndSetState(current, next))

                    return true;

            }

        }



        final void reducePermits(int reductions) {

            for (;;) {

                int current = getState();

                int next = current - reductions;

                if (next > current) // underflow

                    throw new Error("Permit count underflow");

                if (compareAndSetState(current, next))

                    return;

            }

        }



        final int drainPermits() {

            for (;;) {

                int current = getState();

                if (current == 0 || compareAndSetState(current, 0))

                    return current;

            }

        }

    }



    /**

     * NonFair version

     */

    static final class NonfairSync extends Sync {

        private static final long serialVersionUID = -2694183684443567898L;



        NonfairSync(int permits) {

            super(permits);

        }



        protected int tryAcquireShared(int acquires) {

            return nonfairTryAcquireShared(acquires);

        }

    }



    /**

     * Fair version

     */

    static final class FairSync extends Sync {

        private static final long serialVersionUID = 2014338818796000944L;



        FairSync(int permits) {

            super(permits);

        }



        protected int tryAcquireShared(int acquires) {

            for (;;) {

                if (hasQueuedPredecessors())

                    return -1;

                int available = getState();

                int remaining = available - acquires;

                if (remaining < 0 ||

                    compareAndSetState(available, remaining))

                    return remaining;

            }

        }

    }



    /**

     * Creates a {@code Semaphore} with the given number of

     * permits and nonfair fairness setting.

     *

     * @param permits the initial number of permits available.

     *        This value may be negative, in which case releases

     *        must occur before any acquires will be granted.

     */

    public Semaphore(int permits) {

        sync = new NonfairSync(permits);

    }



    /**

     * Creates a {@code Semaphore} with the given number of

     * permits and the given fairness setting.

     *

     * @param permits the initial number of permits available.

     *        This value may be negative, in which case releases

     *        must occur before any acquires will be granted.

     * @param fair {@code true} if this semaphore will guarantee

     *        first-in first-out granting of permits under contention,

     *        else {@code false}

     */

    public Semaphore(int permits, boolean fair) {

        sync = fair ? new FairSync(permits) : new NonfairSync(permits);

    }



    /**

     * Acquires a permit from this semaphore, blocking until one is

     * available, or the thread is {@linkplain Thread#interrupt interrupted}.

     *

     * <p>Acquires a permit, if one is available and returns immediately,

     * reducing the number of available permits by one.

     *

     * <p>If no permit is available then the current thread becomes

     * disabled for thread scheduling purposes and lies dormant until

     * one of two things happens:

     * <ul>

     * <li>Some other thread invokes the {@link #release} method for this

     * semaphore and the current thread is next to be assigned a permit; or

     * <li>Some other thread {@linkplain Thread#interrupt interrupts}

     * the current thread.

     * </ul>

     *

     * <p>If the current thread:

     * <ul>

     * <li>has its interrupted status set on entry to this method; or

     * <li>is {@linkplain Thread#interrupt interrupted} while waiting

     * for a permit,

     * </ul>

     * then {@link InterruptedException} is thrown and the current thread's

     * interrupted status is cleared.

     *

     * @throws InterruptedException if the current thread is interrupted

     */

    public void acquire() throws InterruptedException {

        sync.acquireSharedInterruptibly(1);

    }



    /**

     * Acquires a permit from this semaphore, blocking until one is

     * available.

     *

     * <p>Acquires a permit, if one is available and returns immediately,

     * reducing the number of available permits by one.

     *

     * <p>If no permit is available then the current thread becomes

     * disabled for thread scheduling purposes and lies dormant until

     * some other thread invokes the {@link #release} method for this

     * semaphore and the current thread is next to be assigned a permit.

     *

     * <p>If the current thread is {@linkplain Thread#interrupt interrupted}

     * while waiting for a permit then it will continue to wait, but the

     * time at which the thread is assigned a permit may change compared to

     * the time it would have received the permit had no interruption

     * occurred.  When the thread does return from this method its interrupt

     * status will be set.

     */

    public void acquireUninterruptibly() {

        sync.acquireShared(1);

    }



    /**

     * Acquires a permit from this semaphore, only if one is available at the

     * time of invocation.

     *

     * <p>Acquires a permit, if one is available and returns immediately,

     * with the value {@code true},

     * reducing the number of available permits by one.

     *

     * <p>If no permit is available then this method will return

     * immediately with the value {@code false}.

     *

     * <p>Even when this semaphore has been set to use a

     * fair ordering policy, a call to {@code tryAcquire()} <em>will</em>

     * immediately acquire a permit if one is available, whether or not

     * other threads are currently waiting.

     * This &quot;barging&quot; behavior can be useful in certain

     * circumstances, even though it breaks fairness. If you want to honor

     * the fairness setting, then use

     * {@link #tryAcquire(long, TimeUnit) tryAcquire(0, TimeUnit.SECONDS) }

     * which is almost equivalent (it also detects interruption).

     *

     * @return {@code true} if a permit was acquired and {@code false}

     *         otherwise

     */

    public boolean tryAcquire() {

        return sync.nonfairTryAcquireShared(1) >= 0;

    }



    /**

     * Acquires a permit from this semaphore, if one becomes available

     * within the given waiting time and the current thread has not

     * been {@linkplain Thread#interrupt interrupted}.

     *

     * <p>Acquires a permit, if one is available and returns immediately,

     * with the value {@code true},

     * reducing the number of available permits by one.

     *

     * <p>If no permit is available then the current thread becomes

     * disabled for thread scheduling purposes and lies dormant until

     * one of three things happens:

     * <ul>

     * <li>Some other thread invokes the {@link #release} method for this

     * semaphore and the current thread is next to be assigned a permit; or

     * <li>Some other thread {@linkplain Thread#interrupt interrupts}

     * the current thread; or

     * <li>The specified waiting time elapses.

     * </ul>

     *

     * <p>If a permit is acquired then the value {@code true} is returned.

     *

     * <p>If the current thread:

     * <ul>

     * <li>has its interrupted status set on entry to this method; or

     * <li>is {@linkplain Thread#interrupt interrupted} while waiting

     * to acquire a permit,

     * </ul>

     * then {@link InterruptedException} is thrown and the current thread's

     * interrupted status is cleared.

     *

     * <p>If the specified waiting time elapses then the value {@code false}

     * is returned.  If the time is less than or equal to zero, the method

     * will not wait at all.

     *

     * @param timeout the maximum time to wait for a permit

     * @param unit the time unit of the {@code timeout} argument

     * @return {@code true} if a permit was acquired and {@code false}

     *         if the waiting time elapsed before a permit was acquired

     * @throws InterruptedException if the current thread is interrupted

     */

    public boolean tryAcquire(long timeout, TimeUnit unit)

        throws InterruptedException {

        return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));

    }



    /**

     * Releases a permit, returning it to the semaphore.

     *

     * <p>Releases a permit, increasing the number of available permits by

     * one.  If any threads are trying to acquire a permit, then one is

     * selected and given the permit that was just released.  That thread

     * is (re)enabled for thread scheduling purposes.

     *

     * <p>There is no requirement that a thread that releases a permit must

     * have acquired that permit by calling {@link #acquire}.

     * Correct usage of a semaphore is established by programming convention

     * in the application.

     */

    public void release() {

        sync.releaseShared(1);

    }



    /**

     * Acquires the given number of permits from this semaphore,

     * blocking until all are available,

     * or the thread is {@linkplain Thread#interrupt interrupted}.

     *

     * <p>Acquires the given number of permits, if they are available,

     * and returns immediately, reducing the number of available permits

     * by the given amount.

     *

     * <p>If insufficient permits are available then the current thread becomes

     * disabled for thread scheduling purposes and lies dormant until

     * one of two things happens:

     * <ul>

     * <li>Some other thread invokes one of the {@link #release() release}

     * methods for this semaphore, the current thread is next to be assigned

     * permits and the number of available permits satisfies this request; or

     * <li>Some other thread {@linkplain Thread#interrupt interrupts}

     * the current thread.

     * </ul>

     *

     * <p>If the current thread:

     * <ul>

     * <li>has its interrupted status set on entry to this method; or

     * <li>is {@linkplain Thread#interrupt interrupted} while waiting

     * for a permit,

     * </ul>

     * then {@link InterruptedException} is thrown and the current thread's

     * interrupted status is cleared.

     * Any permits that were to be assigned to this thread are instead

     * assigned to other threads trying to acquire permits, as if

     * permits had been made available by a call to {@link #release()}.

     *

     * @param permits the number of permits to acquire

     * @throws InterruptedException if the current thread is interrupted

     * @throws IllegalArgumentException if {@code permits} is negative

     */

    public void acquire(int permits) throws InterruptedException {

        if (permits < 0) throw new IllegalArgumentException();

        sync.acquireSharedInterruptibly(permits);

    }



    /**

     * Acquires the given number of permits from this semaphore,

     * blocking until all are available.

     *

     * <p>Acquires the given number of permits, if they are available,

     * and returns immediately, reducing the number of available permits

     * by the given amount.

     *

     * <p>If insufficient permits are available then the current thread becomes

     * disabled for thread scheduling purposes and lies dormant until

     * some other thread invokes one of the {@link #release() release}

     * methods for this semaphore, the current thread is next to be assigned

     * permits and the number of available permits satisfies this request.

     *

     * <p>If the current thread is {@linkplain Thread#interrupt interrupted}

     * while waiting for permits then it will continue to wait and its

     * position in the queue is not affected.  When the thread does return

     * from this method its interrupt status will be set.

     *

     * @param permits the number of permits to acquire

     * @throws IllegalArgumentException if {@code permits} is negative

     *

     */

    public void acquireUninterruptibly(int permits) {

        if (permits < 0) throw new IllegalArgumentException();

        sync.acquireShared(permits);

    }



    /**

     * Acquires the given number of permits from this semaphore, only

     * if all are available at the time of invocation.

     *

     * <p>Acquires the given number of permits, if they are available, and

     * returns immediately, with the value {@code true},

     * reducing the number of available permits by the given amount.

     *

     * <p>If insufficient permits are available then this method will return

     * immediately with the value {@code false} and the number of available

     * permits is unchanged.

     *

     * <p>Even when this semaphore has been set to use a fair ordering

     * policy, a call to {@code tryAcquire} <em>will</em>

     * immediately acquire a permit if one is available, whether or

     * not other threads are currently waiting.  This

     * &quot;barging&quot; behavior can be useful in certain

     * circumstances, even though it breaks fairness. If you want to

     * honor the fairness setting, then use {@link #tryAcquire(int,

     * long, TimeUnit) tryAcquire(permits, 0, TimeUnit.SECONDS) }

     * which is almost equivalent (it also detects interruption).

     *

     * @param permits the number of permits to acquire

     * @return {@code true} if the permits were acquired and

     *         {@code false} otherwise

     * @throws IllegalArgumentException if {@code permits} is negative

     */

    public boolean tryAcquire(int permits) {

        if (permits < 0) throw new IllegalArgumentException();

        return sync.nonfairTryAcquireShared(permits) >= 0;

    }



    /**

     * Acquires the given number of permits from this semaphore, if all

     * become available within the given waiting time and the current

     * thread has not been {@linkplain Thread#interrupt interrupted}.

     *

     * <p>Acquires the given number of permits, if they are available and

     * returns immediately, with the value {@code true},

     * reducing the number of available permits by the given amount.

     *

     * <p>If insufficient permits are available then

     * the current thread becomes disabled for thread scheduling

     * purposes and lies dormant until one of three things happens:

     * <ul>

     * <li>Some other thread invokes one of the {@link #release() release}

     * methods for this semaphore, the current thread is next to be assigned

     * permits and the number of available permits satisfies this request; or

     * <li>Some other thread {@linkplain Thread#interrupt interrupts}

     * the current thread; or

     * <li>The specified waiting time elapses.

     * </ul>

     *

     * <p>If the permits are acquired then the value {@code true} is returned.

     *

     * <p>If the current thread:

     * <ul>

     * <li>has its interrupted status set on entry to this method; or

     * <li>is {@linkplain Thread#interrupt interrupted} while waiting

     * to acquire the permits,

     * </ul>

     * then {@link InterruptedException} is thrown and the current thread's

     * interrupted status is cleared.

     * Any permits that were to be assigned to this thread, are instead

     * assigned to other threads trying to acquire permits, as if

     * the permits had been made available by a call to {@link #release()}.

     *

     * <p>If the specified waiting time elapses then the value {@code false}

     * is returned.  If the time is less than or equal to zero, the method

     * will not wait at all.  Any permits that were to be assigned to this

     * thread, are instead assigned to other threads trying to acquire

     * permits, as if the permits had been made available by a call to

     * {@link #release()}.

     *

     * @param permits the number of permits to acquire

     * @param timeout the maximum time to wait for the permits

     * @param unit the time unit of the {@code timeout} argument

     * @return {@code true} if all permits were acquired and {@code false}

     *         if the waiting time elapsed before all permits were acquired

     * @throws InterruptedException if the current thread is interrupted

     * @throws IllegalArgumentException if {@code permits} is negative

     */

    public boolean tryAcquire(int permits, long timeout, TimeUnit unit)

        throws InterruptedException {

        if (permits < 0) throw new IllegalArgumentException();

        return sync.tryAcquireSharedNanos(permits, unit.toNanos(timeout));

    }



    /**

     * Releases the given number of permits, returning them to the semaphore.

     *

     * <p>Releases the given number of permits, increasing the number of

     * available permits by that amount.

     * If any threads are trying to acquire permits, then one

     * is selected and given the permits that were just released.

     * If the number of available permits satisfies that thread's request

     * then that thread is (re)enabled for thread scheduling purposes;

     * otherwise the thread will wait until sufficient permits are available.

     * If there are still permits available

     * after this thread's request has been satisfied, then those permits

     * are assigned in turn to other threads trying to acquire permits.

     *

     * <p>There is no requirement that a thread that releases a permit must

     * have acquired that permit by calling {@link Semaphore#acquire acquire}.

     * Correct usage of a semaphore is established by programming convention

     * in the application.

     *

     * @param permits the number of permits to release

     * @throws IllegalArgumentException if {@code permits} is negative

     */

    public void release(int permits) {

        if (permits < 0) throw new IllegalArgumentException();

        sync.releaseShared(permits);

    }



    /**

     * Returns the current number of permits available in this semaphore.

     *

     * <p>This method is typically used for debugging and testing purposes.

     *

     * @return the number of permits available in this semaphore

     */

    public int availablePermits() {

        return sync.getPermits();

    }



    /**

     * Acquires and returns all permits that are immediately available.

     *

     * @return the number of permits acquired

     */

    public int drainPermits() {

        return sync.drainPermits();

    }



    /**

     * Shrinks the number of available permits by the indicated

     * reduction. This method can be useful in subclasses that use

     * semaphores to track resources that become unavailable. This

     * method differs from {@code acquire} in that it does not block

     * waiting for permits to become available.

     *

     * @param reduction the number of permits to remove

     * @throws IllegalArgumentException if {@code reduction} is negative

     */

    protected void reducePermits(int reduction) {

        if (reduction < 0) throw new IllegalArgumentException();

        sync.reducePermits(reduction);

    }



    /**

     * Returns {@code true} if this semaphore has fairness set true.

     *

     * @return {@code true} if this semaphore has fairness set true

     */

    public boolean isFair() {

        return sync instanceof FairSync;

    }



    /**

     * Queries whether any threads are waiting to acquire. Note that

     * because cancellations may occur at any time, a {@code true}

     * return does not guarantee that any other thread will ever

     * acquire.  This method is designed primarily for use in

     * monitoring of the system state.

     *

     * @return {@code true} if there may be other threads waiting to

     *         acquire the lock

     */

    public final boolean hasQueuedThreads() {

        return sync.hasQueuedThreads();

    }



    /**

     * Returns an estimate of the number of threads waiting to acquire.

     * The value is only an estimate because the number of threads may

     * change dynamically while this method traverses internal data

     * structures.  This method is designed for use in monitoring of the

     * system state, not for synchronization control.

     *

     * @return the estimated number of threads waiting for this lock

     */

    public final int getQueueLength() {

        return sync.getQueueLength();

    }



    /**

     * Returns a collection containing threads that may be waiting to acquire.

     * Because the actual set of threads may change dynamically while

     * constructing this result, the returned collection is only a best-effort

     * estimate.  The elements of the returned collection are in no particular

     * order.  This method is designed to facilitate construction of

     * subclasses that provide more extensive monitoring facilities.

     *

     * @return the collection of threads

     */

    protected Collection<Thread> getQueuedThreads() {

        return sync.getQueuedThreads();

    }



    /**

     * Returns a string identifying this semaphore, as well as its state.

     * The state, in brackets, includes the String {@code "Permits ="}

     * followed by the number of permits.

     *

     * @return a string identifying this semaphore, as well as its state

     */

    public String toString() {

        return super.toString() + "[Permits = " + sync.getPermits() + "]";

    }

}

View Code

Semaphore是通过共享锁实现的。根据共享锁的获取原则，Semaphore分为"公平信号量"和"非公平信号量"。

"公平信号量"和"非公平信号量"的区别

"公平信号量"和"非公平信号量"的释放信号量的机制是一样的！不同的是它们获取信号量的机制：线程在尝试获取信号量许可时，对于公平信号量而言，如果当前线程不在CLH队列的头部，则排队等候；而对于非公平信号量而言，无论当前线程是不是在CLH队列的头部，它都会直接获取信号量。该差异具体的体现在，它们的tryAcquireShared()函数的实现不同。

"公平信号量"类

static final class FairSync extends Sync {

    private static final long serialVersionUID = 2014338818796000944L;



    FairSync(int permits) {

        super(permits);

    }



    protected int tryAcquireShared(int acquires) {

        for (;;) {

            if (hasQueuedPredecessors())

                return -1;

            int available = getState();

            int remaining = available - acquires;

            if (remaining < 0 ||

                compareAndSetState(available, remaining))

                return remaining;

        }

    }

}

View Code

"非公平信号量"类

static final class NonfairSync extends Sync {

    private static final long serialVersionUID = -2694183684443567898L;



    NonfairSync(int permits) {

        super(permits);

    }



    protected int tryAcquireShared(int acquires) {

        return nonfairTryAcquireShared(acquires);

    }

}

View Code

下面，我们逐步的对它们的源码进行分析。

1. 信号量构造函数

public Semaphore(int permits) {

    sync = new NonfairSync(permits);

}



public Semaphore(int permits, boolean fair) {

    sync = fair ? new FairSync(permits) : new NonfairSync(permits);

}

从中，我们可以信号量分为“公平信号量(FairSync)”和“非公平信号量(NonfairSync)”。Semaphore(int permits)函数会默认创建“非公平信号量”。

2. 公平信号量获取和释放

2.1 公平信号量的获取
Semaphore中的公平信号量是FairSync。它的获取API如下：

public void acquire() throws InterruptedException {

    sync.acquireSharedInterruptibly(1);

}



public void acquire(int permits) throws InterruptedException {

    if (permits < 0) throw new IllegalArgumentException();

    sync.acquireSharedInterruptibly(permits);

}

信号量中的acquire()获取函数，实际上是调用的AQS中的acquireSharedInterruptibly()。

 

acquireSharedInterruptibly()的源码如下：

public final void acquireSharedInterruptibly(int arg)

        throws InterruptedException {

    // 如果线程是中断状态，则抛出异常。

    if (Thread.interrupted())

        throw new InterruptedException();

    // 否则，尝试获取“共享锁”；获取成功则直接返回，获取失败，则通过doAcquireSharedInterruptibly()获取。

    if (tryAcquireShared(arg) < 0)

        doAcquireSharedInterruptibly(arg);

}

 

Semaphore中”公平锁“对应的tryAcquireShared()实现如下：

protected int tryAcquireShared(int acquires) {

    for (;;) {

        // 判断“当前线程”是不是CLH队列中的第一个线程线程，

        // 若是的话，则返回-1。

        if (hasQueuedPredecessors())

            return -1;

        // 设置“可以获得的信号量的许可数”

        int available = getState();

        // 设置“获得acquires个信号量许可之后，剩余的信号量许可数”

        int remaining = available - acquires;

        // 如果“剩余的信号量许可数>=0”，则设置“可以获得的信号量许可数”为remaining。

        if (remaining < 0 ||

            compareAndSetState(available, remaining))

            return remaining;

    }

}

说明：tryAcquireShared()的作用是尝试获取acquires个信号量许可数。
对于Semaphore而言，state表示的是“当前可获得的信号量许可数”。

 

下面看看AQS中doAcquireSharedInterruptibly()的实现：

private void doAcquireSharedInterruptibly(long arg)

    throws InterruptedException {

    // 创建”当前线程“的Node节点，且Node中记录的锁是”共享锁“类型；并将该节点添加到CLH队列末尾。

    final Node node = addWaiter(Node.SHARED);

    boolean failed = true;

    try {

        for (;;) {

            // 获取上一个节点。

            // 如果上一节点是CLH队列的表头，则”尝试获取共享锁“。

            final Node p = node.predecessor();

            if (p == head) {

                long r = tryAcquireShared(arg);

                if (r >= 0) {

                    setHeadAndPropagate(node, r);

                    p.next = null; // help GC

                    failed = false;

                    return;

                }

            }

            // 当前线程一直等待，直到获取到共享锁。

            // 如果线程在等待过程中被中断过，则再次中断该线程(还原之前的中断状态)。

            if (shouldParkAfterFailedAcquire(p, node) &&

                parkAndCheckInterrupt())

                throw new InterruptedException();

        }

    } finally {

        if (failed)

            cancelAcquire(node);

    }

}

说明：doAcquireSharedInterruptibly()会使当前线程一直等待，直到当前线程获取到共享锁(或被中断)才返回。
(01) addWaiter(Node.SHARED)的作用是，创建”当前线程“的Node节点，且Node中记录的锁的类型是”共享锁“(Node.SHARED)；并将该节点添加到CLH队列末尾。关于Node和CLH在"Java多线程系列--“JUC锁”03之 公平锁(一)"已经详细介绍过，这里就不再重复说明了。
(02) node.predecessor()的作用是，获取上一个节点。如果上一节点是CLH队列的表头，则”尝试获取共享锁“。
(03) shouldParkAfterFailedAcquire()的作用和它的名称一样，如果在尝试获取锁失败之后，线程应该等待，则返回true；否则，返回false。
(04) 当shouldParkAfterFailedAcquire()返回ture时，则调用parkAndCheckInterrupt()，当前线程会进入等待状态，直到获取到共享锁才继续运行。
doAcquireSharedInterruptibly()中的shouldParkAfterFailedAcquire(), parkAndCheckInterrupt等函数在"Java多线程系列--“JUC锁”03之 公平锁(一)"中介绍过，这里也就不再详细说明了。

2.2 公平信号量的释放

Semaphore中公平信号量(FairSync)的释放API如下：

public void release() {

    sync.releaseShared(1);

}



public void release(int permits) {

    if (permits < 0) throw new IllegalArgumentException();

    sync.releaseShared(permits);

}

信号量的releases()释放函数，实际上是调用的AQS中的releaseShared()。

 

releaseShared()在AQS中实现，源码如下：

public final boolean releaseShared(int arg) {

    if (tryReleaseShared(arg)) {

        doReleaseShared();

        return true;

    }

    return false;

}

说明：releaseShared()的目的是让当前线程释放它所持有的共享锁。
它首先会通过tryReleaseShared()去尝试释放共享锁。尝试成功，则直接返回；尝试失败，则通过doReleaseShared()去释放共享锁。

 

Semaphore重写了tryReleaseShared()，它的源码如下：

protected final boolean tryReleaseShared(int releases) {

    for (;;) {

        // 获取“可以获得的信号量的许可数”

        int current = getState();

        // 获取“释放releases个信号量许可之后，剩余的信号量许可数”

        int next = current + releases;

        if (next < current) // overflow

            throw new Error("Maximum permit count exceeded");

        // 设置“可以获得的信号量的许可数”为next。

        if (compareAndSetState(current, next))

            return true;

    }

}

 

如果tryReleaseShared()尝试释放共享锁失败，则会调用doReleaseShared()去释放共享锁。doReleaseShared()的源码如下：

private void doReleaseShared() {

    for (;;) {

        // 获取CLH队列的头节点

        Node h = head;

        // 如果头节点不为null，并且头节点不等于tail节点。

        if (h != null && h != tail) {

            // 获取头节点对应的线程的状态

            int ws = h.waitStatus;

            // 如果头节点对应的线程是SIGNAL状态，则意味着“头节点的下一个节点所对应的线程”需要被unpark唤醒。

            if (ws == Node.SIGNAL) {

                // 设置“头节点对应的线程状态”为空状态。失败的话，则继续循环。

                if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))

                    continue;

                // 唤醒“头节点的下一个节点所对应的线程”。

                unparkSuccessor(h);

            }

            // 如果头节点对应的线程是空状态，则设置“文件点对应的线程所拥有的共享锁”为其它线程获取锁的空状态。

            else if (ws == 0 &&

                     !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))

                continue;                // loop on failed CAS

        }

        // 如果头节点发生变化，则继续循环。否则，退出循环。

        if (h == head)                   // loop if head changed

            break;

    }

}

说明：doReleaseShared()会释放“共享锁”。它会从前往后的遍历CLH队列，依次“唤醒”然后“执行”队列中每个节点对应的线程；最终的目的是让这些线程释放它们所持有的信号量。

 

3 非公平信号量获取和释放

Semaphore中的非公平信号量是NonFairSync。在Semaphore中，“非公平信号量许可的释放(release)”与“公平信号量许可的释放(release)”是一样的。
不同的是它们获取“信号量许可”的机制不同，下面是非公平信号量获取信号量许可的代码。

非公平信号量的tryAcquireShared()实现如下：

protected int tryAcquireShared(int acquires) {

    return nonfairTryAcquireShared(acquires);

}

 

nonfairTryAcquireShared()的实现如下：

final int nonfairTryAcquireShared(int acquires) {

    for (;;) {

        // 设置“可以获得的信号量的许可数”

        int available = getState();

        // 设置“获得acquires个信号量许可之后，剩余的信号量许可数”

        int remaining = available - acquires;

        // 如果“剩余的信号量许可数>=0”，则设置“可以获得的信号量许可数”为remaining。

        if (remaining < 0 ||

            compareAndSetState(available, remaining))

            return remaining;

    }

}

说明：非公平信号量的tryAcquireShared()调用AQS中的nonfairTryAcquireShared()。而在nonfairTryAcquireShared()的for循环中，它都会直接判断“当前剩余的信号量许可数”是否足够；足够的话，则直接“设置可以获得的信号量许可数”，进而再获取信号量。
而公平信号量的tryAcquireShared()中，在获取信号量之前会通过if (hasQueuedPredecessors())来判断“当前线程是不是在CLH队列的头部”，是的话，则返回-1。 

 

Semaphore示例

 1 import java.util.concurrent.ExecutorService; 

 2 import java.util.concurrent.Executors; 

 3 import java.util.concurrent.Semaphore; 

 4 

 5 public class SemaphoreTest1 { 

 6     private static final int SEM_MAX = 10;

 7     public static void main(String[] args) { 

 8         Semaphore sem = new Semaphore(SEM_MAX);

 9         //创建线程池

10         ExecutorService threadPool = Executors.newFixedThreadPool(3);

11         //在线程池中执行任务

12         threadPool.execute(new MyThread(sem, 5));

13         threadPool.execute(new MyThread(sem, 4));

14         threadPool.execute(new MyThread(sem, 7));

15         //关闭池

16         threadPool.shutdown();

17     }

18 }

19 

20 class MyThread extends Thread {

21     private volatile Semaphore sem;    // 信号量

22     private int count;        // 申请信号量的大小 

23 

24     MyThread(Semaphore sem, int count) {

25         this.sem = sem;

26         this.count = count;

27     }

28 

29     public void run() {

30         try {

31             // 从信号量中获取count个许可

32             sem.acquire(count);

33 

34             Thread.sleep(2000);

35             System.out.println(Thread.currentThread().getName() + " acquire count="+count);

36         } catch (InterruptedException e) {

37             e.printStackTrace();

38         } finally {

39             // 释放给定数目的许可，将其返回到信号量。

40             sem.release(count);

41             System.out.println(Thread.currentThread().getName() + " release " + count + "");

42         }

43     }

44 }

(某一次)运行结果：

pool-1-thread-1 acquire count=5

pool-1-thread-2 acquire count=4

pool-1-thread-1 release 5

pool-1-thread-2 release 4

pool-1-thread-3 acquire count=7

pool-1-thread-3 release 7

结果说明：信号量sem的许可总数是10个；共3个线程，分别需要获取的信号量许可数是5,4,7。前面两个线程获取到信号量的许可后，sem中剩余的可用的许可数是1；因此，最后一个线程必须等前两个线程释放了它们所持有的信号量许可之后，才能获取到7个信号量许可。

 

---

更多内容 

1. Java多线程系列--“JUC锁”01之 框架 

2. Java多线程系列--“JUC锁”02之 互斥锁ReentrantLock 

3. Java多线程系列--“JUC锁”03之 公平锁(一) 

4. Java多线程系列--“JUC锁”04之 公平锁(二)

5. Java多线程系列--“JUC锁”05之 非公平锁

6. Java多线程系列--“JUC锁”06之 Condition条件 

7. Java多线程系列--“JUC锁”07之 LockSupport 

8. Java多线程系列--“JUC锁”08之 共享锁和ReentrantReadWriteLock

9. Java多线程系列--“JUC锁”09之 CountDownLatch原理和示例

10. Java多线程系列--“JUC锁”10之 CyclicBarrier原理和示例

11. Java多线程系列目录(共xx篇)