Introducción al semáforo Semáforo del componente de sincronización del marco JUC-AQS

Concepto de semáforo

El semáforo es un semáforo de contador, que mantiene un conjunto de permisos para controlar el consumo y el reciclaje de ciertos recursos. Cuando el hilo llama al método adquirir (), si el permiso es insuficiente, el hilo se bloqueará hasta que haya un permiso disponible. El método release () liberará una licencia.

Semáforo

Semaphore proporciona dos métodos de construcción:

public Semaphore(int permits) {          //参数permits表示许可数目，即同时可以允许多少线程进行访问
    sync = new NonfairSync(permits);
}
public Semaphore(int permits, boolean fair) {    //这个多了一个参数fair表示是否是公平的，即等待时间越久的越先获取许可
    sync = (fair)? new FairSync(permits) : new NonfairSync(permits);
}

Permítanme hablar sobre algunos de los métodos más importantes en la clase Semaphore. El primero es los métodos adquirir () y liberar ():

public void acquire() throws InterruptedException {  }     //获取一个许可
public void acquire(int permits) throws InterruptedException { }    //获取permits个许可
public void release() { }          //释放一个许可
public void release(int permits) { }    //释放permits个许可

acquire()Se utiliza para obtener una licencia. Si no se puede obtener una licencia, esperará hasta que se obtenga la licencia.

release()Se usa para liberar licencias. Tenga en cuenta que debe obtener permiso antes de liberar la licencia.

Estos cuatro métodos serán bloqueados. Si desea obtener el resultado de la ejecución inmediatamente, puede usar los siguientes métodos:

public boolean tryAcquire() { };    //尝试获取一个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire(long timeout, TimeUnit unit) throws InterruptedException { };  //尝试获取一个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false
public boolean tryAcquire(int permits) { }; //尝试获取permits个许可，若获取成功，则立即返回true，若获取失败，则立即返回false
public boolean tryAcquire(int permits, long timeout, TimeUnit unit) throws InterruptedException { }; //尝试获取permits个许可，若在指定的时间内获取成功，则立即返回true，否则则立即返回false

Además, la cantidad de licencias disponibles se puede obtener a través del método availablePermits ().

Veamos el uso específico de Semaphore a través de un ejemplo:

Si una fábrica tiene 5 máquinas, pero hay 8 trabajadores, una máquina solo puede ser utilizada por un trabajador al mismo tiempo. Solo después de que se haya agotado, otros trabajadores pueden seguir usándola. Entonces podemos lograrlo a través de Semaphore:

package com.bestksl.example.aqs;

import java.util.concurrent.Semaphore;

public class test {
    public static void main(String[] args) {
        int N = 8;            //工人数
        Semaphore semaphore = new Semaphore(5); //机器数目
        for (int i = 0; i < N; i++)
            new Worker(i, semaphore).start();
    }

    
}
// 工人类
class Worker extends Thread {
    private int num;
    private Semaphore semaphore;

    public Worker(int num, Semaphore semaphore) {
        this.num = num;
        this.semaphore = semaphore;
    }

    @Override
    public void run() {
        try {
            semaphore.acquire();
            System.out.println("工人" + this.num + "占用一个机器在生产...");
            Thread.sleep(2000);
            System.out.println("工人" + this.num + "释放出机器");
            semaphore.release();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Resultado de ejecución

工人0占用一个机器在生产...
工人1占用一个机器在生产...
工人2占用一个机器在生产...
工人4占用一个机器在生产...
工人5占用一个机器在生产...
工人0释放出机器
工人2释放出机器
工人3占用一个机器在生产...
工人7占用一个机器在生产...
工人4释放出机器
工人5释放出机器
工人1释放出机器
工人6占用一个机器在生产...
工人3释放出机器
工人7释放出机器
工人6释放出机器