Semaphore类

Semaphore字面意思是信号量。他主要用于控制有限的资源的访问数量。

场景：

一个厕所只有3个坑位，但是有10个人来上厕所，那怎么办？假设10的人的编号分别为1-10，并且1号先到厕所，10号最后到厕所。那么1-3号来的时候必然有可用坑位，顺利如厕，4号来的时候需要看看前面3人是否有人出来了，如果有人出来，进去，否则等待。同样的道理，4-10号也需要等待正在上厕所的人出来后才能进去，并且谁先进去这得看等待的人是否有素质，是否能遵守先来先上的规则。

基本函数

构造函数

1
2


public Semaphore(int permits)
public Semaphore(int permits, boolean fair)

permits 代表可用资源数量，fair代表是否先来先用

acquire函数

1
2


public void acquire() throws InterruptedException 
public void acquire(int permits) throws InterruptedException    

用来申请permits个资源，没有则为1，如果没有那么多资源，则阻塞线程，若被打断，抛出InterruptedException异常

acquireUninterruptibly函数

与上类似，只不过就算线程在申请资源过程中被打断，依然会继续申请，获取资源的时间可能会有所变化。

tryAcquire函数

tryAcquire函数用来获取可用资源，但是这类函数能够有时间的限制，如果超时，立即返回，有几种类型的函数，签名分别如下：

1
2
3
4
5
6


public boolean tryAcquire()
public boolean tryAcquire(long timeout, TimeUnit unit)
        throws InterruptedException
public boolean tryAcquire(int permits)
public boolean tryAcquire(int permits, long timeout, TimeUnit unit)
        throws InterruptedException

1.第一个函数用来申请一个资源，如果当前有可用资源，立即返回true，否则立即返回false；
2.第二个函数用来申请一个资源，指定一个超时时间，如果当前可以资源数量足够，立即返回true，否则最多等待给定的时间，如果时间到还是未能获取资源，则返回false；如果等待过程中线程被打断，抛出InterruptedException异常；
3.和1一样，只是申请permits个资源
4.和2一样，只是申请permits个资源

release函数

释放资源

availablePermits函数

用来获取当前可用的资源数量

1

public int availablePermits()

drainPermits函数

用来申请当前所有可用的资源

reducePermits函数

用来禁止某些资源不可用

isFair函数

用来判断当前的信号量是采用什么类型的策略

hasQueuedThreads函数

判断是否有现成正在等待申请资源

getQueueLength函数

返回正在等待申请资源的线程的数量

getQueuedThreads函数

返回当前正在等待申请资源的线程集合

demo

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63


public class TestSemaphore {
    public static void main(String[] args) throws Exception {
        Semaphore wc = new Semaphore(3, true); // 3个坑位
        for (int i = 1; i <= 6; i++) {
            Thread t = new Thread(new Person("第" + i + "个人", wc));
            t.start();
            Thread.sleep(new Random().nextInt(300));
        }
    }

    static class Person implements Runnable {
        private String name;
        private Semaphore wc;

        public Person(String name, Semaphore wc) {
            this.name = name;
            this.wc = wc;
        }

        public void run() {
            System.out.print(name + "：憋死老子了!");
            if (wc.availablePermits() > 0) {
                System.out.println("天助我也，有坑位！");
            } else {
                System.out.println("卧槽，没坑位了，等会儿吧...");
            }
            try {
                wc.acquire(); //申请坑位
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(name + "：终于轮到我了，拉屎就是爽！");
            try {
                Thread.sleep(new Random().nextInt(1000)); // 模拟上厕所时间。
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(name + "：拉完了，好臭!");
            wc.release();
        }
    }
}

结果：

第1个人：憋死老子了!天助我也，有坑位！ 
第1个人：终于轮到我了，拉屎就是爽！ 
第2个人：憋死老子了!天助我也，有坑位！ 
第2个人：终于轮到我了，拉屎就是爽！ 
第3个人：憋死老子了!天助我也，有坑位！ 
第3个人：终于轮到我了，拉屎就是爽！ 
第3个人：拉完了，好臭! 
第4个人：憋死老子了!天助我也，有坑位！ 
第4个人：终于轮到我了，拉屎就是爽！ 
第5个人：憋死老子了!卧槽，没坑位了，等会儿吧… 
第6个人：憋死老子了!卧槽，没坑位了，等会儿吧… 
第2个人：拉完了，好臭! 
第5个人：终于轮到我了，拉屎就是爽！ 
第4个人：拉完了，好臭! 
第6个人：终于轮到我了，拉屎就是爽！ 
第1个人：拉完了，好臭! 
第6个人：拉完了，好臭! 
第5个人：拉完了，好臭!

文章目录