Java 7之多线程第10篇 - Semaphore_java7 并发编程 semaphore-优快云博客

Semaphore用于保存当前可用许可的数量。是通过共享锁实现的。根据共享锁的获取原则，Semaphore分为"公平信号量"和"非公平信号量"。

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

如果要使用Semaphore对象时，首先通过构造函数取得对象，如下：

[java] view plain copy

print ?

public Semaphore(int permits) { // 构造函数默认使用非公平的方式获取
sync = new NonfairSync(permits);
}
public Semaphore(int permits, boolean fair) { // 构造函数中指定获取的方式
sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}

    public Semaphore(int permits) {  // 构造函数默认使用非公平的方式获取
        sync = new NonfairSync(permits);
    }
    public Semaphore(int permits, boolean fair) { // 构造函数中指定获取的方式
        sync = fair ? new FairSync(permits) : new NonfairSync(permits);
    }

然后就可以调用Semaphore对象进行信号量的获取了，如下：

[java] view plain copy

print ?

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

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


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

1、公平信号量的获取

首先来看公平信号量的获取，方法如下：

[java] view plain copy

print ?

public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
// 如果线程是中断状态，则抛出异常
if (Thread.interrupted())
throw new InterruptedException();
// 尝试获取共享锁；获取成功则直接返回，获取失败，则通过doAcquireSharedInterruptibly()获取。
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}

public final void acquireSharedInterruptibly(int arg)   throws InterruptedException {
    // 如果线程是中断状态，则抛出异常
    if (Thread.interrupted())
        throw new InterruptedException();
    // 尝试获取共享锁；获取成功则直接返回，获取失败，则通过doAcquireSharedInterruptibly()获取。
    if (tryAcquireShared(arg) < 0)
        doAcquireSharedInterruptibly(arg);
}

如果tryAcquireShared()方法获取失败，通常会返回一个小于0的数量。Semaphore中公平锁对应的tryAcquireShared()实现如下：

[java] view plain copy

print ?

protected int tryAcquireShared(int acquires) {
for (;;) {
// 判断当前线程是不是队列中的第一个线程。若是的话，则返回-1，跳出死循环
if (hasQueuedPredecessors())
return -1;
int available = getState(); // 获取当前可用的信号量的许可数
// 设置获得acquires个信号量许可之后，剩余的信号量许可数
int remaining = available - acquires;
// 如果剩余的信号量许可数>=0”，则设置可以获得的信号量许可数为remaining。
if (remaining < 0 || compareAndSetState(available, remaining))
return remaining;
}
}

 protected int tryAcquireShared(int acquires) {
            for (;;) {
                // 判断当前线程是不是队列中的第一个线程。若是的话，则返回-1，跳出死循环
                if (hasQueuedPredecessors())
                    return -1;
                int available = getState();  // 获取当前可用的信号量的许可数
                // 设置获得acquires个信号量许可之后，剩余的信号量许可数
                int remaining = available - acquires;
                // 如果剩余的信号量许可数>=0”，则设置可以获得的信号量许可数为remaining。
                if (remaining < 0 || compareAndSetState(available, remaining))
                    return remaining;
            }
        }

返回的是remaining，如果为-1，表示获取失败。如果为>=0，则预示了其他共享获取操作能否成功。

如上方法获取失败后，调用doAcquireSharedInterruptibly()方法，源码如下：

[java] view plain copy

print ?

private void doAcquireSharedInterruptibly(long arg) throws InterruptedException {
// 创建当前线程的Node节点，且Node中记录的锁是共享锁类型；并将该节点添加到队列末尾。
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
for (;;) {
// 获取上一个节点，如果上一节点是队列的表头，则尝试获取共享锁
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);
}
}

private void doAcquireSharedInterruptibly(long arg)   throws InterruptedException {
    // 创建当前线程的Node节点，且Node中记录的锁是共享锁类型；并将该节点添加到队列末尾。
    final Node node = addWaiter(Node.SHARED);
    boolean failed = true;
    try {
        for (;;) {
            // 获取上一个节点，如果上一节点是队列的表头，则尝试获取共享锁
            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);
    }
}

2、非公平信号量的获取

[java] view plain copy

print ?

protected int tryAcquireShared(int acquires) {
return nonfairTryAcquireShared(acquires);
}

protected int tryAcquireShared(int acquires) {
    return nonfairTryAcquireShared(acquires);
}

在这个方法里调用了如下方法：

[java] view plain copy

print ?

final int nonfairTryAcquireShared(int acquires) { // 非公平方式获取共享锁的一定量许可
for (;;) {
int available = getState();
int remaining = available - acquires;
if (remaining < 0 || compareAndSetState(available, remaining))// 如果remaining>=0，则通过CAS方式更新当前许可的数量
return remaining;
}
}

 final int nonfairTryAcquireShared(int acquires) { // 非公平方式获取共享锁的一定量许可
            for (;;) {
                int available = getState();
                int remaining = available - acquires;
                if (remaining < 0 || compareAndSetState(available, remaining))// 如果remaining>=0，则通过CAS方式更新当前许可的数量
                    return remaining;
            }
        }

判断当前剩余的信号量许可数，返回小于0的数表示获取失败，大于等于0表示成功。

非公平和公平主要体现在tryAcquireShared()方法的实现上。

（1）非公平获取如果当前可用的信号量许可大于等于请求数，则通过CAS修改剩余许可量并返回，如果小于的话，返回小于0的数，表示获取失败。

（2）公平获取在获取时还会判断。如果当前线程不在队列的头部，则返回-1，排队等候；然后再去判断信号量许可。

3、公平信号量的释放

调用如下方法来释放信号量许可，如下：

[java] view plain copy

print ?

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

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

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

调用无参数的release()方法默认只释放一个信号量许可，而下面的可以指定：

[java] view plain copy

print ?

public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
doReleaseShared();
return true;
}
return false;
}

 public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) {
            doReleaseShared();
            return true;
        }
        return false;
    }

首先调用tryReleaseShared()方法去释放，源代码如下：

[java] view plain copy

print ?

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

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()的源码如下：

[java] view plain copy

print ?

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

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

4、非公平信号量的释放

[java] view plain copy

print ?

protected int tryAcquireShared(int acquires) {
return nonfairTryAcquireShared(acquires);
}

protected int tryAcquireShared(int acquires) {
    return nonfairTryAcquireShared(acquires);
}

[java] view plain copy

print ?

final int nonfairTryAcquireShared(int acquires) {
for (;;) {
// 设置可以获得的信号量的许可数
int available = getState();
// 设置获得acquires个信号量许可之后，剩余的信号量许可数
int remaining = available - acquires;
// 如果剩余的信号量许可数>=0，则设置可以获得的信号量许可数为remaining
if (remaining < 0 ||
compareAndSetState(available, remaining))
return remaining;
}
}

final int nonfairTryAcquireShared(int acquires) {
    for (;;) {
        // 设置可以获得的信号量的许可数
        int available = getState();
        // 设置获得acquires个信号量许可之后，剩余的信号量许可数
        int remaining = available - acquires;
        // 如果剩余的信号量许可数>=0，则设置可以获得的信号量许可数为remaining
        if (remaining < 0 ||
            compareAndSetState(available, remaining))
            return remaining;
    }
}

举个例子，如下：

[java] view plain copy

print ?

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
public class SemaphoreTest1 {
private static final int SEM_MAX = 10;
public static void main(String[] args) {
Semaphore sem = new Semaphore(SEM_MAX);
//创建线程池
ExecutorService threadPool = Executors.newFixedThreadPool(3);
//在线程池中执行任务
threadPool.execute(new MyThread(sem, 5));
threadPool.execute(new MyThread(sem, 4));
threadPool.execute(new MyThread(sem, 7));
//关闭池
threadPool.shutdown();
}
}
class MyThread extends Thread {
private volatile Semaphore sem; // 信号量
private int count; // 申请信号量的大小
MyThread(Semaphore sem, int count) {
this.sem = sem;
this.count = count;
}
public void run() {
try {
// 从信号量中获取count个许可
sem.acquire(count);
Thread.sleep(2000);
System.out.println(Thread.currentThread().getName() + " acquire count="+count);
} catch (InterruptedException e) {
e.printStackTrace();
} finally {
// 释放给定数目的许可，将其返回到信号量。
sem.release(count);
System.out.println(Thread.currentThread().getName() + " release " + count + "");
}
}
}

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

public class SemaphoreTest1 { 
    private static final int SEM_MAX = 10;
    public static void main(String[] args) { 
        Semaphore sem = new Semaphore(SEM_MAX);
        //创建线程池
        ExecutorService threadPool = Executors.newFixedThreadPool(3);
        //在线程池中执行任务
        threadPool.execute(new MyThread(sem, 5));
        threadPool.execute(new MyThread(sem, 4));
        threadPool.execute(new MyThread(sem, 7));
        //关闭池
        threadPool.shutdown();
    }
}

class MyThread extends Thread {
    private volatile Semaphore sem;    // 信号量
    private int count;        // 申请信号量的大小 

    MyThread(Semaphore sem, int count) {
        this.sem = sem;
        this.count = count;
    }

    public void run() {
        try {
            // 从信号量中获取count个许可
            sem.acquire(count);

            Thread.sleep(2000);
            System.out.println(Thread.currentThread().getName() + " acquire count="+count);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            // 释放给定数目的许可，将其返回到信号量。
            sem.release(count);
            System.out.println(Thread.currentThread().getName() + " release " + count + "");
        }
    }
}

某一次运行后的结果如下：

[java] view plain copy

print ?

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

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

转载自http://blog.youkuaiyun.com/mazhimazh/