线程安全（八）Semaphore

系列文章目录

线程安全（一）java对象头分析以及锁状态
线程安全（二）java中的CAS机制
线程安全（三）实现方法sychronized与ReentrantLock（阻塞同步）
线程安全（四）Java内存模型与volatile关键字
线程安全（五）线程状态和线程创建
线程安全（六）线程池
线程安全（七）ThreadLocal和java的四种引用
线程安全（八）Semaphore
线程安全（九）CyclicBarrier
线程安全（十）AQS(AbstractQueuedSynchronizer)

0.前言

Semaphore ：信号量，使用AQS类型的同步状态持有当前可用许可的数量。
控制访问特定资源的线程数量，来控制并发。

1.方法分析

1.1.构造方法：

Semaphore(int permits):创建具有给定许可数的计数信号量并设置为非公平信号量。

Semaphore(int permits,boolean fair):当fair等于true时，创建具有给定许可数的计数信号量并设置为公平信号量。

1.2.方法

• void acquire():从此信号量获取一个许可前线程将一直阻塞。
• void acquire(int n):从此信号量获取给定数目许可，在提供这些许可前一直将线程阻塞。比如n=2，就相当于一辆车占了两个车位。
• void release():释放一个许可，将其返回给信号量。
• void release(int n):释放n个许可。
• int availablePermits()：当前可用的许可数。此方法通常用于调试，因为许可数量（通路）可能是实时在改变的。
• getQueueLength() 获取等待许可的线程个数。
• hasQueuedThreads() 判断有没有线程在等待这个许可。

尝试获取许可；

1. tryAcquire()
2. tryAcquire（ long timeout , TimeUint unit)
3. tryAcquire(int permits)
4. tryAcquire(int permits , long timeout , TimeUint unit)

tryAcquire 方法，是 acquire 的扩展版，
tryAcquire 作用是尝试得获取许可，如果未传参数，就是尝试获取一个许可，
如果传了参数，就是在指定时间 timeout  内 尝试 获取 permits 个许可。
如果获取不到则返回false，获取成功返回false。

2.用法

2.1.普通使用

package com.relife.object;

import java.time.LocalDate;
import java.time.LocalTime;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.Semaphore;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

public class Test8_Semaphore {
    // 全局的计数信号量
    private static final Semaphore semaphore = new Semaphore(2);
    // 线程池
    private static final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(10, 10, 60, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>());

    public static void main(String[] args) throws InterruptedException {
        String[] nameArray = {"一", "二", "三", "四", "五", "六", "七"};
        for (int i = 0; i < nameArray.length; i++) {
            Thread t1 = new InformationThread(nameArray[i]);
            threadPool.execute(t1);
        }
        Thread.sleep(20000L);
        threadPool.shutdown();
        System.out.println("结束");
    }

    public static class InformationThread extends Thread {
        private final String name;

        public InformationThread(String name) {
            this.name = name;
        }

        @Override
        public void run() {
            Thread.currentThread().setName(name);
            try {
                LocalTime date = LocalTime.now();
                System.out.println(Thread.currentThread().getName() + "->acquire前当前可使用的许可数为：" + semaphore.availablePermits());
                semaphore.acquire();
                System.out.println(Thread.currentThread().getName()  + "->acquire后当前可使用的许可数为：" + semaphore.availablePermits() + "开始获取时间：" + date + "获取时间：" + LocalTime.now());
                Thread.sleep(2000);
                System.out.println(Thread.currentThread().getName()  + "->要准备释放许可证");
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                semaphore.release();
            }
        }
    }
}

结论

进入线程,持有许可，运行完，释放许可。
如果没有剩余许可可持有，线程等待。一旦有许可，持有
int availablePermits()：当前可用的许可数。此方法通常用于调试，因为许可数量（通路）可能是实时在改变的。

2.2.实现线程交错

n个线程交替打印

package com.relife.object;

import java.util.concurrent.Semaphore;

public class Test8_Semaphore1 {
    // 以A开始的信号量,初始信号量数量为1
    private static Semaphore A = new Semaphore(1);
    // B、C信号量,A完成后开始,初始信号数量为0
    private static Semaphore B = new Semaphore(0);
    private static Semaphore C = new Semaphore(0);

    static class ThreadA extends Thread {
        private String[] arrayStr;
        public ThreadA(String[] arrayStr){
            this.arrayStr = arrayStr;
        }
        @Override
        public void run() {
            try {
                for (int i = 0; i < arrayStr.length; i++) {
                    A.acquire();// A获取信号执行,A信号量减1,当A为0时将无法继续获得该信号量
                    System.out.println(arrayStr[i]);
                    B.release();// B释放信号，B信号量加1（初始为0），此时可以获取B信号量
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    static class ThreadB extends Thread {
        private String[] arrayStr;
        public ThreadB(String[] arrayStr){
            this.arrayStr = arrayStr;
        }
        @Override
        public void run() {
            try {
                for (int i = 0; i < arrayStr.length; i++) {
                    B.acquire();// A获取信号执行,A信号量减1,当A为0时将无法继续获得该信号量
                    System.out.println(arrayStr[i]);
                    C.release();// B释放信号，B信号量加1（初始为0），此时可以获取B信号量
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    static class ThreadC extends Thread {
        private String[] arrayStr;
        public ThreadC(String[] arrayStr){
            this.arrayStr = arrayStr;
        }
        @Override
        public void run() {
            try {
                for (int i = 0; i < arrayStr.length; i++) {
                    C.acquire();// A获取信号执行,A信号量减1,当A为0时将无法继续获得该信号量
                    System.out.println(arrayStr[i]);
                    A.release();// B释放信号，B信号量加1（初始为0），此时可以获取B信号量
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        String[] arrayStrA = new String[]{"a","b","c","d"};
        String[] arrayStrB = new String[]{"1","2","3","4"};
        String[] arrayStrC = new String[]{"A","B","C","D"};
        new ThreadA(arrayStrA).start();
        new ThreadB(arrayStrB).start();
        new ThreadC(arrayStrC).start();
    }
}

结论

针对每个线程都有一个信号量控制。
每当有一个线程结束，就释放指定下一个执行线程的信号量,让下一个线程执行。

2.3.公平与非公平信号量

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