国产欧美va欧美va在线观看,久久精品成人欧美大片,男女一边摸一边做爽爽电视

1. Semaphore 定義

Semaphore 主要用于限量控制并發執行代碼的工具類, 其內部通過一個 permit 來進行定義并發執行的數量, 其實可以理解為一個限制數量的 ReadLock 獲取.

Semaphore 主要特點:

Semaphore 方法的實現通過 Sync(AQS的繼承類)代理來實現
2.支持公平與非公平模式, 都是在AQS的子類里面進行, 主要區分在 tryAcquire 里面

先看一個簡單的 demo

import org.apache.log4j.Logger;

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

/**
 * Created by xjk on 9/15/16.
 */
public class SemaphoreExample implements Runnable {

    private static Logger logger = Logger.getLogger(SemaphoreExample.class);

    private static final Semaphore semaphore = new Semaphore(3, true); // 初始化 Semaphore, 限流閥值 為3, 并且指定為公平模式
    private static final AtomicInteger counter = new AtomicInteger(0);

    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(5);
        for (int i = 0; i < 5; i++) {
            executorService.execute(new SemaphoreExample()); // 執行 permit 的獲取,
        }
        executorService.shutdown();
    }

    public void run() {
        while(counter.incrementAndGet() <= 5) { // Semaphore 被循環獲取 5次
            try {
                semaphore.acquire();                // 進行 permit 的獲取
            } catch (InterruptedException e) {
                logger.info("["+Thread.currentThread().getName()+"] Interrupted in acquire().");
            }
            logger.info("["+Thread.currentThread().getName()+"] semaphore acquired: "+counter.get());
            semaphore.release();
        }
    }
}

執行結果

[2017-02-12 15:27:12,973] INFO  pool-1-thread-2 (SemaphoreExample.java:35) - [pool-1-thread-2] semaphore acquired: 2
[2017-02-12 15:27:12,973] INFO  pool-1-thread-3 (SemaphoreExample.java:35) - [pool-1-thread-3] semaphore acquired: 3
[2017-02-12 15:27:12,973] INFO  pool-1-thread-1 (SemaphoreExample.java:35) - [pool-1-thread-1] semaphore acquired: 2
[2017-02-12 15:27:12,978] INFO  pool-1-thread-5 (SemaphoreExample.java:35) - [pool-1-thread-5] semaphore acquired: 7
[2017-02-12 15:27:12,978] INFO  pool-1-thread-4 (SemaphoreExample.java:35) - [pool-1-thread-4] semaphore acquired: 6

執行步驟:
上面的代碼不好直接看出, 但可以這樣理解, 有一段代碼, 再

2. Semaphore 構造函數

Semaphore 的功能均由內部類 NonfairSync, FairSync 代理來實現

/**
 * 使用非公平版本構件 Semaphore
 */
public KSemaphore(int permits){
    sync = new NonfairSync(permits);
}

/**
 * 指定版本構件 Semaphore
 */
public KSemaphore(int permits, boolean fair){
    sync = fair ? new FairSync(permits) : new NonfairSync(permits);
}

3. Semaphore 內部類 Sync

/**
 * Synchronization implementation for semaphore. Uses AQS state
 * to represent permits. Subclassed into fair and nonfair
 * versions
 */
/** AQS 的子類主要定義獲取釋放 lock */
abstract static class Sync extends KAbstractQueuedSynchronizer{
    private static final long serialVersionUID = 1192457210091910933L;

    /**
     * 指定 permit 初始化 Semaphore
     */
    Sync(int permits){
        setState(permits);
    }

    /**
     * 返回剩余 permit
     */
    final int getPermits(){
        return getState();
    }

    /**
     * 獲取 permit
     */
    final int nonfairTryAcquireShared(int acquires){
        for(;;){
            int available = getState();
            int remaining = available - acquires; // 判斷獲取 acquires 的剩余 permit 數目
            if(remaining < 0 ||
                    compareAndSetState(available, remaining)){ // cas改變 state
                return remaining;
            }
        }
    }

    /**
     * 釋放 lock
     */
    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)){  // cas改變 state
                return true;
            }
        }
    }

    final void reducePermits(int reductions){ // 減少 permits
        for(;;){
            int current = getState();
            int next = current - reductions;
            if(next > current){ // underflow
                throw new Error(" Permit count underflow ");
            }
            if(compareAndSetState(current, next)){
                return;
            }
        }
    }

    /** 將 permit 置為 0 */
    final int drainPermits(){
        for(;;){
            int current = getState();
            if(current == 0 || compareAndSetState(current, 0)){
                return current;
            }
        }
    }

}

4. Semaphore 內部類 FairSync, NonfairSync

這兩個類均繼承 Sync, 兩者的區別主要在于在獲取時判斷是否有線程在 AQS 的 Sync Queue 里面進行等待獲取

/**
 * Nonfair version
 */
/** 非公平版本獲取 permit */
static final class NonfairSync extends Sync{

    private static final long serialVersionUID = -2694183684443567898L;

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

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

/**
 * Fair version
 */
/** 公平版本獲取 permit */
static final class FairSync extends Sync{

    private static final long serialVersionUID = 3245289457313211085L;

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

    /**
     * 公平版本獲取 permit 主要看是否由前繼節點
     */
    @Override
    protected int tryAcquireShared(int acquires) {
        for(;;){
            if(hasQueuedPredecessors()){ // 1. 判斷是否Sync Queue 里面是否有前繼節點
                return -1;
            }
            int available = getState();
            int remaining = available - acquires;
            if(remaining < 0 ||
                    compareAndSetState(available, remaining)){ // 2. cas 改變state
                return remaining;
            }
        }
    }
}

5. Semaphore permit 獲取方法

下面這些方法主要通過內部類 Sync, FairSync, NonFairSync 來進行實現

/**
 * 調用 acquireSharedInterruptibly 響應中斷的方式獲取 permit
 */
public void acquire() throws InterruptedException{
    sync.acquireSharedInterruptibly(1);
}


/**
 * 調用 acquireUninterruptibly 非響應中斷的方式獲取 permit
 */
public void acquireUninterruptibly(){
    sync.acquireShared(1);
}


/**
 * 嘗試獲取 permit
 */
public boolean tryAcquire(){
    return sync.nonfairTryAcquireShared(1) >= 0;
}


/**
 * 嘗試的獲取 permit, 支持超時與中斷
 */
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException{
    return sync.tryAcquireSharedNanos(1, unit.toNanos(timeout));
}

/**
 * 支持中斷的獲取permit
 */
public void acquire(int permits) throws InterruptedException{
    if(permits < 0){
        throw new IllegalArgumentException();
    }
    sync.acquireSharedInterruptibly(permits);
}


/**
 * 不響應中斷的獲取 permit
 */
public void acquireUninterruptibly(int permits){
    if(permits < 0) throw new IllegalArgumentException();
    sync.acquireShared(permits);
}


/**
 * 嘗試獲取 permit
 */
public boolean tryAcquire(int permits){
    if(permits < 0) throw new IllegalArgumentException();
    return sync.nonfairTryAcquireShared(permits) >= 0;
}


/**
 * 嘗試 支持超時機制, 支持中斷 的獲取 permit
 */
public boolean tryAcquire(int permits, long timout, TimeUnit unit) throws InterruptedException{
    if(permits < 0) throw new IllegalArgumentException();
    return sync.tryAcquireSharedNanos(permits, unit.toNanos(timout));
}

6. Semaphore permit 釋放方法

/**
 * 釋放 permit
 */
public void release(){
    sync.releaseShared(1);
}

/**
 * 釋放 permit
 */
public void release(int permits){
    if(permits < 0) throw new IllegalArgumentException();
    sync.releaseShared(permits);
}

7. Semaphore 工具類方法

/**
 * 返回可用的 permit
 */
public int availablePermits(){
    return sync.getPermits();
}


/**
 * 消耗光 permit
 */
public int drainPermits(){
    return sync.drainPermits();
}


/**
 * 減少 reduction 個permit
 */
protected void reducePermits(int reduction){
   if(reduction < 0) throw new IllegalArgumentException();
    sync.reducePermits(reduction);
}


/**
 * 判斷是否是公平版本
 */
public boolean isFair(){
    return sync instanceof FairSync;
}


/**
 * 返回 AQS 中 Sync Queue 里面的等待線程
 */
public final boolean hasQueuedThreads(){
    return sync.hasQueuedThreads();
}

/**
 * 返回 AQS 中 Sync Queue 里面的等待線程長度
 */
public final int getQueueLength(){
    return sync.getQueueLength();
}


/**
 * 返回 AQS 中 Sync Queue 里面的等待線程
 */
protected Collection<Thread> getQueueThreads(){
    return sync.getQueuedThreads();
}

8. 總結

Semaphore 通過 AQS中的 state 來進行控制 permit 的獲取控制, 其實它就是一個限制數量的 ReadLock; 但要真正理解 Semaphore, 還需要理解 AbstractQueuedSynchronizer

參考
Java 8 源碼分析 AbstractQueuedSynchronizer
Java 8 源碼分析 ReentrantReadWriteLock
Java多線程之JUC包：Semaphore源碼學習筆記

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频

Semaphore 源碼分析 (基于Java 8)

Semaphore 源碼分析 (基于Java 8)

1. Semaphore 定義

2. Semaphore 構造函數

3. Semaphore 內部類 Sync

4. Semaphore 內部類 FairSync, NonfairSync

5. Semaphore permit 獲取方法

6. Semaphore permit 釋放方法

7. Semaphore 工具類方法

8. 總結

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美 国产 综合 欧美 视频

Semaphore 源碼分析 (基于Java 8)

1. Semaphore 定義

2. Semaphore 構造函數

3. Semaphore 內部類 Sync

4. Semaphore 內部類 FairSync, NonfairSync

5. Semaphore permit 獲取方法

6. Semaphore permit 釋放方法

7. Semaphore 工具類方法

8. 總結

推薦閱讀更多精彩內容

三个男躁一个女,国精产品一区一手机的秘密,麦子交换系列最经典十句话,欧美国产综合欧美视频