多線程（十三、AQS原理-Semaphore信號(hào)量）

Semaphore介紹

Semaphore，限制對(duì)共享資源訪問的最大線程數(shù)量，要訪問共享資源，需要先申請(qǐng)?jiān)S可，申請(qǐng)到許可才能訪問。訪問結(jié)果了，釋放許可。

案例：

3個(gè)線程：Thread-1、Thread-2、Thread-3。一個(gè)許可數(shù)為2的公平策略的Semaphore。

線程的調(diào)用順序如下：
Thread-1 申請(qǐng)一個(gè)許可，等待幾秒鐘，繼續(xù)執(zhí)行
Thread-2 申請(qǐng)2個(gè)許可，許可不足，阻塞
Thread-3 申請(qǐng)一個(gè)許可，等待幾秒鐘，繼續(xù)執(zhí)行
Thread-1,Thread-3,釋放許可之后，Thread-2可以申請(qǐng)?jiān)S可，成功執(zhí)行。

代碼：

Thread-1/3

import java.util.concurrent.Semaphore;

public class Task1 implements Runnable{

    private Semaphore semaphore;

    public Task1(Semaphore semaphore) {
        this.semaphore = semaphore;
    }

    @Override
    public void run() {

        try {
            semaphore.acquire();
            System.out.println(Thread.currentThread().getName() + "獲取到許可....");
            Thread.sleep(3000);
            System.out.println(Thread.currentThread().getName() + "執(zhí)行....");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println(Thread.currentThread().getName() + "釋放許可....");
            semaphore.release();
        }
    }
}

Thread-2

import java.util.concurrent.Semaphore;

public class Task2 implements Runnable{

    private Semaphore semaphore;

    public Task2(Semaphore semaphore) {
        this.semaphore = semaphore;
    }

    @Override
    public void run() {

        try {
            System.out.println(Thread.currentThread().getName() + "申請(qǐng)?jiān)S可....");
            semaphore.acquire(2);
            System.out.println(Thread.currentThread().getName() + "獲取到許可....");
            Thread.sleep(3000);
            System.out.println(Thread.currentThread().getName() + "執(zhí)行....");
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            System.out.println(Thread.currentThread().getName() + "釋放許可....");
            semaphore.release(2);
        }
    }
}

啟動(dòng)文件

import java.text.ParseException;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Semaphore;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class Main {

    public static void main(String[] args) throws ParseException, InterruptedException {
        Semaphore semaphore = new Semaphore(2, true);

        ReentrantLock lock = new ReentrantLock(true);
        Condition condition = lock.newCondition();
        Thread t1 = new Thread(new Task1(semaphore),"Thread-1");
        t1.start();
        Thread.sleep(2000);
        Thread t2 = new Thread(new Task2(semaphore),"Thread-2");
        Thread t3 = new Thread(new Task1(semaphore),"Thread-3");
        t2.start();
        t3.start();
    }
}

結(jié)果：

源碼分析

創(chuàng)建公平的Semaphore，就是直接修改AQS的同步狀態(tài)state

Thread-1,申請(qǐng)?jiān)S可，執(zhí)行AQS的acquireSharedInterruptibly

Semaphore是如何實(shí)現(xiàn)tryAcquireShared方法的

此時(shí)，Thread-1申請(qǐng)一個(gè)，是足夠的，返回成功，然后持有許可，此時(shí)state=1。

Thread-2申請(qǐng)2個(gè)許可，但是state=1,不夠的。

Thread-2會(huì)申請(qǐng)失敗，進(jìn)入doAcquireSharedInterruptibly

doAcquireSharedInterruptibly方法之前的文章也介紹過了，這里不再詳細(xì)介紹，最終Thread-2被包裝成節(jié)點(diǎn)放【等待隊(duì)列】，同時(shí)需要設(shè)置【等待隊(duì)列】頭結(jié)點(diǎn)為SIGNAL狀態(tài)，然后Thread-2阻塞了。

Thread-3申請(qǐng)一個(gè)許可，是成功的，然后持有許可，此時(shí)state=0.

Thread-1，釋放了許可，則state=1;

然后執(zhí)行doReleaseShared，設(shè)置頭節(jié)點(diǎn)狀態(tài)為0，準(zhǔn)備喚醒后繼節(jié)點(diǎn)，也就是Thread-2.

此時(shí)，可能Thread-3還沒有釋放許可，state=1,那么Thread-2又會(huì)被阻塞。

Thread-3,釋放許可，state=2,繼續(xù)喚醒Thread-2.

Thread-2,獲取許可成功，state=0,繼續(xù)執(zhí)行。

Thread-2,釋放許可，state=2,程序執(zhí)行完成。