Java多线程再学习，温故知新（十四）Semaphore

不念不忘少年蓝@ 2022-04-23 09:18 175阅读 0赞

Semaphore

一个计数信号量。从概念上讲，信号量维护了一个许可集。如有必要，在许可可用前会阻塞每一个 acquire()，然后再获取该许可。每个 release() 添加一个许可，从而可能释放一个正在阻塞的获取者。但是，不使用实际的许可对象，Semaphore 只对可用许可的号码进行计数，并采取相应的行动。

Semaphore 通常用于限制可以访问某些资源（物理或逻辑的）的线程数目。

控制线程进入方法

import java.util.concurrent.Semaphore;
    
    class MyThread extends Thread {
        private Semaphore semaphore;
        
        public MyThread(String name, Semaphore semaphore) {
            super(name);
            this.semaphore = semaphore;
        }
        
        public void run() {        
            int count = 3;
            System.out.println(Thread.currentThread().getName() + " trying to acquire");
            try {
                semaphore.acquire(count);
                System.out.println(Thread.currentThread().getName() + " acquire successfully");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                semaphore.release(count);
                System.out.println(Thread.currentThread().getName() + " release successfully");
            }
        }
    }
    
    public class SemaphoreDemo {
        public final static int SEM_SIZE = 10;
        
        public static void main(String[] args) {
            Semaphore semaphore = new Semaphore(SEM_SIZE);
            MyThread t1 = new MyThread("t1", semaphore);
            MyThread t2 = new MyThread("t2", semaphore);
            t1.start();
            t2.start();
            int permits = 5;
            System.out.println(Thread.currentThread().getName() + " trying to acquire");
            try {
                semaphore.acquire(permits);
                System.out.println(Thread.currentThread().getName() + " acquire successfully");
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                semaphore.release();
                System.out.println(Thread.currentThread().getName() + " release successfully");
            }
            
                    
        }
    }

## 源码分析 ##

Semaphore通过自定义的同步器维护了一个或多个共享资源，线程通过调用acquire获取共享资源，通过调用release释放，它是一个共享锁。

### acquire函数 ###

此方法从信号量获取一个（多个）许可，在提供一个许可前一直将线程阻塞，或者线程被中断，其源码如下

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

该方法中将会调用Sync对象的acquireSharedInterruptibly（从AQS继承而来的方法）方法，最终可以获取大致的方法调用序列（假设使用非公平策略）。如下图所示。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2llZmxleA_size_16_color_FFFFFF_t_70][]

###  release函数 ###

此方法释放一个（多个）许可，将其返回给信号量，源码如下。

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2llZmxleA_size_16_color_FFFFFF_t_70 1][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2llZmxleA_size_16_color_FFFFFF_t_70]: /images/20220321/a448464be34045658ead9ed33edfdbf2.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2llZmxleA_size_16_color_FFFFFF_t_70 1]: /images/20220321/216a336857da4079b5affd5f0f54a98d.png