多线程基础(十九)：Semaphore源码分析

最新推荐文章于 2022-05-29 22:12:28 发布

冬天里的懒猫

最新推荐文章于 2022-05-29 22:12:28 发布

阅读量351

点赞数

分类专栏： JAVA 文章标签：多线程 java 并发编程分布式面试

本文链接：https://blog.csdn.net/dhaibo1986/article/details/109649263

版权

JAVA 专栏收录该内容

124 篇文章 15 订阅

订阅专栏

1.类结构及注释

1.1 类结构

Semaphore是基于AQS实现的信号量，这个类主要用于控制线程的访问数，或者对并发的数量进行控制。以将资源的被获取方的速度限制在特定的值内。
其类结构如下：

其内部有持有基于AQS的Sync类，Sync类有FairSyn和NonfairSync两个类来实现公平和非公平锁。

1.2 注释部分

Semaphore是一个用于计数的信号量，从概念上讲，信号量实际上是一组许可证，每个acquire都需要获得许可证才能运行。而每个release方法则会将之前获取的许可证释放。但是，再Semaphore中，并没有实际的许可证对象存在，Semaphore只是保留了一个用于计数的数量并进行相应的加减操作。
信号量通常用于限制线程数量，而不能访问某些资源。例如，如下是一个使用信号量控制项目pool访问的类。

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;
    }
  }}

在获取之前，每个线程必须从信号量获取许可，以确保每个获取项是可以使用的。当线程完成该获取项之后，它将返回到pool中，并向信号量返回一个许可。从而允许另一个线程获取该项。需要注意的是，在调用acquire时，不会保持任何锁同步，因为这将阻止某个项返回到pool中，信号量封装了限制访问池所需的同步，与维护池本身一致性所需的任何同步分开。
初始化一个信号量可以用作互斥锁，这样的话该信号量最多只有一个许可。这通常被称为二进制信号量，因为它只有两种状态，一个许可可用，或者没有许可可用。当以这种方式使用时，二进制信号量具有锁定属性，这与许多Lock的实现不同。这个可以由所有者之外的线程释放，因为信号量本身没有所有权概念。这在某些特殊情况下（如死锁恢复）会很有用。
此类的构造函数可以选择公平参数fairness。设置为false时，此类不保证线程获得许可的顺序。特别是允许插队，也就是说，可以在正在等待的线程之前为调用acquire的线程分配一个许可-从逻辑上讲，新线程将自己置于该线程的头部等待线程的队列。当公平性设置为true时，信号量可确保选择调用任何acquire()方法的线程以处理它们调用这些方法的顺序获得许可（先进先出; FIFO）。请注意，FIFO排序必须适用于这些方法中的特定内部执行点。因此，一个线程有可能在另一个线程之前调acquisition，但在另一个线程之后到达排序点，并且类似地从该方法返回时也是如此。另请注意，未定时的tryAcquire方法不遵循公平性设置，但会采用任何可用的许可。
通常，用于控制资源访问的信号量应初始化为公平，以确保没有线程因访问资源而挨饿。当使用信号量进行其他类型的同步控制时，非公平排序的吞吐量优势通常会超过公平考虑。
此类还提供了方便的方法来同时acquire（int）获取和release（int）释放多个许可。当在没有设置公平的情况下使用这些方法时，请注意无限期推迟的风险增加。
内存一致性分析：调用release（）之类的“发布”方法之前，线程中的操作发生在成功的“获取”方法（如acquire()之前）在另一个线程中。

2.内部类Sync

与众多Lock的实现一样，Semaphore也是基于AQS实现的。在其内部有Sync类。Sync继承了AbstractQueueSynhronizer。

abstract static class Sync extends AbstractQueuedSynchronizer {
    private static final long serialVersionUID = 1192457210091910933L;

    Sync(int permits) {
        setState(permits);
    }

    final int getPermits() {
        return getState();
    }
}

其实现的方法如下:

2.1 nonfairTryAcquireShared

非公平锁的模式下尝试获取共享锁。

final int nonfairTryAcquireShared(int acquires) {
    //死循环
    for (;;) {
        //获得state状态
        int available = getState();
        //用当前的可用state的值减去acquires
        int remaining = available - acquires;
        //如果前面减去的结果小于0，或者cas的方式设置state成功，则退出
        if (remaining < 0 ||
            compareAndSetState(available, remaining))
            return remaining;
    }
}

2.2 tryReleaseShared

释放共享锁

protected final boolean tryReleaseShared(int releases) {
   //死循环
    for (;;) {
        //获得当前的状态
        int current = getState();
        //next为当前state+release的值
        int next = current + releases;
        //如果next比current小，那么只有一种可能就是越界，导致这个结果为负数
        if (next < current) // overflow
            //抛出异常
            throw new Error("Maximum permit count exceeded");
        如果没有异常，则cas设置next 成功则为true
        if (compareAndSetState(current, next))
            return true;
    }
}

2.3 reducePermits

减少许可证

final void reducePermits(int reductions) {
    //死循环
    for (;;) {
        //获得当前的state
        int current = getState();
        //next为当前的state减去应该减少的reductions
        int next = current - reductions;
        //如果next任然大于current则说明没有这么多许可证，此时抛出异常
        if (next > current) // underflow
            throw new Error("Permit count underflow");
        //采用cas修改
        if (compareAndSetState(current, next))
            return;
    }
}

2.4 drainPermits

将许可证清空

final int drainPermits() {
    //死循环
    for (;;) {
        //current为当前的state
        int current = getState();
        //如果current为0或者cas将current设置为0
        if (current == 0 || compareAndSetState(current, 0))
            //返回
            return current;
    }
}

3.NonfairSync与FairSync

3.1 NonfairSync

NonfairSync是Sync的非公平锁的实现，其源码如下：

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);
    }
}

实际上只需要实现一个关键的方法，tryAcquireShared。这个方法调用了前面在sync中定义的nonfairTryAcquireShared方法。

3.2 FairSync

FairSync是Sync的公平锁的实现，其源码如下：

static final class FairSync extends Sync {
    private static final long serialVersionUID = 2014338818796000944L;

    FairSync(int permits) {
        super(permits);
    }

    protected int tryAcquireShared(int acquires) {
       //死循环
        for (;;) {
            //判断队列中是否存在前任节点，如果存在，返回-1，将当前线程阻塞
            if (hasQueuedPredecessors())
                return -1;
            //available为当前state
            int available = getState();
            //remaing为available减去acquires
            int remaining = available - acquires;
            //如果remaining小于0 或者cas设置为0 则返回
            if (remaining < 0 ||
                compareAndSetState(available, remaining))
                return remaining;
        }
    }
}

4.构造方法

4.1 Semaphore(int permits)

public Semaphore(int permits) {
    sync = new NonfairSync(permits);
}

默认情况下创建了一个非公平锁。

4.2 Semaphore(int permits, boolean fair)

public Semaphore(int permits, boolean fair) {
    sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}

创建的时候可以指定公平性，所谓非公平锁，在Semaphore中，就是当线程获得锁的时候，可以尝试进行一次插队，如果不成功再进行排队。那么公平锁的话，就是一上来就排队。

5.其他方法

5.1 acquire

从Semaphore中获得许可，阻塞，直到获取到可用的许可证为止。或者线程被中断。
如果能及时获取一个许可，那么减少这个许可的数量。
如果没有可用的许可，则出于线程调度目的，当前线程将被禁用，并处于休眠状态，直到发生以下两种情况之一：
其他一些线程为此信号量调用{release方法，接下来将为当前线程分配许可；或某些其他线程interrupt当前线程。

public void acquire() throws InterruptedException {
    sync.acquireSharedInterruptibly(1);
}

5.2 acquireUninterruptibly

获取一个许可，阻塞，直到许可可用。不支持中断。
如果能及时获取一个许可，那么减少这个许可的数量。
如果没有可用的许可，则当前线程将出于线程调度目的而被禁用，并处于休眠状态，直到某个其他线程为此信号量调用release方法，然后将为当前线程分配许可。
如果当前线程在等待许可时被interrupt中断，则它将继续等待，但是与没有许可的情况相比，为该线程分配许可的时间可能会有所变化。发生中断。当线程确实从该方法返回时，将设置其中断状态。

public void acquireUninterruptibly() {
    sync.acquireShared(1);
}

5.3 tryAcquire

仅在调用时可用时，才从此信号量获取许可。如果许可证可用，则获取许可证并立即返回，其值为true，从而将可用许可证数量减少一个。
如果没有许可，则此方法将立即返回值false。
即使已将此信号量设置为使用公平的排序策略，无论是否有其他线程正在等待，对tryAcquire的调用都可能会立即获得许可。这种插入是指，即使再某些情况下，这种行为也会破坏公平性。如果要遵守公平性设置，请使用等效的tryAcquire（long，TimeUnit）和tryAcquire（0，TimeUnit.SECONDS），这些方法还会检测中断。

public boolean tryAcquire() {
    return sync.nonfairTryAcquireShared(1) >= 0;
}

5.4 tryAcquire(long timeout, TimeUnit unit)

如果在给定的等待时间内可用，并且当前线程尚未被中断interrupt ，则从此信号量获取许可。
如果许可证可用，则获取许可证并立即返回，其值为true，从而将可用许可证数量减少一个。
如果没有可用的许可，则出于线程调度的目的，当前线程将被禁用，并处于休眠状态，直到发生以下三种情况之一：

其他一些线程为此信号量调用release方法，接下来将为当前线程分配许可；
或其他某个线程interrupt当前线程；
或经过了指定的等待时间。
如果经过了许可，则返回true，如果当前线程，在进入此方法时已设置其中断状态；或在等待获得许可interrupt被中断，
将引发InterruptedException并清除当前线程的中断状态。
如果经过了指定的等待时间，则返回值false。如果时间小于或等于零，则该方法将根本不等待。

public boolean tryAcquire(long timeout, TimeUnit unit)
    throws InterruptedException {
    return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}

5.5 release

释放一个许可证，将其返回给信号量。
发放许可证，将可用许可证数量增加一个。如果有任何线程试图获取许可，则选择一个线程并授予刚刚释放的许可。出于线程调度目的而启用（重新）该线程。
不要求释放许可证的线程必须通过调用acquire获得该许可证。通过在应用程序中编程约定，可以正确使用信号量。

public void release() {
    sync.releaseShared(1);
}

5.6 acquire(int permits)

从此信号量获取给定数量的许可，阻塞直到所有许可都可用，或者线程interrupt。
这个方法可以一次性获得多个许可证，如果这些许可是可用的，则及时返回。减少许可的可用总数。

如果没有足够的许可，则出于线程调度的目的，当前线程将被禁用，并处于休眠状态，直到发生以下两种情况之一：

其他一些线程为此信号量调用release方法之一，接下来将为当前线程分配许可，并且可用许可的数量可以满足此请求；- 某些其他线程 interrupt 当前线程。

如果当前线程，在进入此方法时已设置其中断状态；或在等待许可时被中断，将抛出InterruptedException，并清除中断状态。
相反，将要分配给该线程的所有许可都分配给其他尝试获取许可的线程，就像通过调用release使许可可用一样。

public void acquire(int permits) throws InterruptedException {
    if (permits < 0) throw new IllegalArgumentException();
    sync.acquireSharedInterruptibly(permits);
}

5.7 acquireUninterruptibly(int permits)

从该信号量获取给定数量的许可，直到所有条件都可用为止都将被阻止。
获取给定数量的许可（如果有），然后立即返回，将可用许可的数量减少给定数量。如果没有足够的许可，则当前线程出于线程调度目的而被禁用，并处于休眠状态，直到其他线程调用此信号量的release方法之一，当前线程将被分配许可，并且可用许可的数量可以满足该请求。
如果当前线程在等待许可时interrupt被中断，则它将继续等待，并且其在队列中的位置不受影响。当线程确实从该方法返回时，将设置其中断状态。

public void acquireUninterruptibly(int permits) {
    if (permits < 0) throw new IllegalArgumentException();
    sync.acquireShared(permits);
}

5.8 tryAcquire(int permits)

仅在调用时所有可用的情况下，从此信号量获取给定的许可数。如果有许可，则获取给定的许可数，并立即返回，值为{@code true}，从而减少了给定数量的可用许可证。
如果没有足够的许可证，则此方法将立即返回false，并且可用许可证的数量不变。
即使已将此信号量设置为使用公平的排序策略，无论是否有其他线程正在等待，对tryAcquire的调用都会立即获得许可。即使破坏公平性，这种插入行为在某些情况下也可能有用。如果要遵守公平性设置，请使用几乎等效的tryAcquire（int，long，TimeUnit）tryAcquire（permits，0，TimeUnit.SECONDS）它还会检测到中断。

public boolean tryAcquire(int permits) {
    if (permits < 0) throw new IllegalArgumentException();
    return sync.nonfairTryAcquireShared(permits) >= 0;
}

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

如果所有信号都在给定的等待时间内可用，并且当前线程尚未interrupt中断，则从此信号量获取给定数量的许可。
如果有可用许可证，则获取给定数量的许可证，并立即返回，其值为true，从而将可用许可证的数量减少给定数量。
如果没有足够的许可，则出于线程调度的目的，当前线程将被禁用，并且将处于休眠状态，直到发生以下三种情况之一：

其他一些线程为此信号量调用release方法之一，接下来将为当前线程分配许可，并且可用许可的数量可以满足此请求；- 要么其他一些线程interrupt interrupts当前线程；
要么经过指定的等待时间。

如果获得许可，则返回值 true。
如果当前线程：
在进入此方法时已设置其中断状态；或在等待获取许可时interrupt被中断，
然后将引发 InterruptedException并清除当前线程的中断状态。相反，将要分配给该线程的所有许可，都分配给其他尝试获取许可的线程，就好像通过调用release()使许可可用一样。如果经过了指定的等待时间，则返回值false。如果时间小于或等于零，则该方法根本不会等待。将分配给此线程的任何许可证，而是分配给其他尝试获取的线程许可，就像通过调用release()来获得许可一样。

public boolean tryAcquire(int permits, long timeout, TimeUnit unit)
    throws InterruptedException {
    if (permits < 0) throw new IllegalArgumentException();
    return sync.tryAcquireSharedNanos(permits, unit.toNanos(timeout));
}

5.10 release(int permits)

释放给定数量的许可证，将其返回到信号。
释放给定数量的许可证，将可用许可证的数量增加该数量。如果有任何线程试图获取许可，则选择一个线程并给出刚刚释放的许可。如果可用许可的数量满足该线程的请求，则出于线程调度的目的，（重新）启用该线程。如果满足该线程的请求后仍然有可用的许可，则将这些许可依次分配给其他尝试获取许可的线程。
无需要求释放许可的线程必须通过调用acquire获得许可。通过在应用程序中编程约定，可以正确使用信号量。

public void release(int permits) {
    if (permits < 0) throw new IllegalArgumentException();
    sync.releaseShared(permits);
}

6.总结

本文对Semaphore的源码进行了分析，Semphore类似于交通控制的信号灯，通过许可证的方式，对竞争的资源的并发程度进行了控制。

冬天里的懒猫

关注

0
点赞
踩
4

收藏

觉得还不错? 一键收藏
0
评论
多线程基础(十九)：Semaphore源码分析

文章目录1.类结构及注释1.1 类结构1.2 注释部分2.内部类Sync2.1 nonfairTryAcquireShared2.2 tryReleaseShared2.3 reducePermits2.4 drainPermits3.NonfairSync与FairSync3.1 NonfairSync3.2 FairSync4.构造方法4.1 Semaphore(int permits)4.2 Semaphore(int permits, boolean fair)5.其他方法5.1 acquire5.
复制链接

扫一扫