Cola de bloqueo ArrayBlockingQueue implementa el modelo de consumidor productor

Diagrama de cola de bloqueo: 

        La diferencia entre una cola de bloqueo y una cola normal es que cuando la cola está vacía, se bloqueará la operación de obtener elementos de la cola, o cuando la cola está llena, se bloqueará la operación de agregar elementos a la cola. Los subprocesos que intentan obtener elementos de la cola de bloqueo vacía se bloquearán hasta que otros subprocesos inserten nuevos elementos en la cola vacía. De manera similar, los subprocesos que intentan agregar nuevos elementos a una cola de bloqueo completa también se bloquearán hasta que otros subprocesos liberen la cola nuevamente.

        Hay varias colas de bloqueo. Este artículo solo utiliza una de las dos colas de bloqueo más utilizadas: ArrayBlockingQueue.

        ArrayBlockingQueue: una cola de bloqueo basada en una implementación de matriz. La capacidad debe especificarse al crear un objeto ArrayBlockingQueue. Y puede especificar la equidad y la injusticia, lo cual es injusto por defecto.

 

       El escenario de cola de bloqueo simplemente se ajusta al modelo productor-consumidor en el sistema operativo. En el problema tradicional productor-consumidor, las operaciones wait () y signal () deben implementarse en una posición específica. El orden no se puede revertir, que es más incómodo. El paquete java.util.concurrent introducido por jdk 5.0 obviamente simplifica muy bien el problema productor-consumidor, y todo se hace automáticamente. Wait () y signal () no necesitan escribirse, lo cual es genial.

put (): se utiliza para almacenar elementos hasta el final de la cola, si la cola está llena, espere;

take (): se usa para tomar elementos del jefe del equipo, si la cola está vacía, espere;

 

       Descripción del código:

       El hilo se implementa heredando la clase Thread para anular el método de ejecución.

        Math.Random () genera un número de punto flotante aleatorio de 0 a 1 (sin incluir 0 y 1). Después de expandir en 10 veces +1, el resultado es un número entero aleatorio de 1 a 10, de modo que cada producto producido por el El productor se coloca en la cola de bloqueo Después del final de la cola (o el consumidor toma un producto del encabezado de la cola de bloqueo), el subproceso correspondiente permanecerá inactivo durante 1 a 10 ms

import java.util.concurrent.ArrayBlockingQueue;

public class Test {
    private int queueSize = 10;//初始化阻塞队列长度为10
    private ArrayBlockingQueue<Integer> queue = new ArrayBlockingQueue<Integer>(queueSize);

    public static void main(String[] args)  {
        Test test = new Test();
        Producer producer = test.new Producer();
        Consumer consumer = test.new Consumer();

        producer.start();
        consumer.start();
    }

    class Consumer extends Thread{

        @Override   //此注解用于检测是否重写了父类的run方法，如果下行的run单词写错编译器就会报红
        public void run() {
            consume();
        }

        private void consume() {
            int ran;//随机生成数1-10放在ran中
            while(true){
                try {
                    ran=(int)Math.random()*10+1;//产生1-10的随机数
                    queue.take();
                    System.out.println("从队列取走一个元素，队列剩余"+queue.size()+"个元素");
                    sleep(ran);//线程休眠产生的随机时间ran
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    class Producer extends Thread{
        @Override   
        public void run() {
            produce();
        }
        private void produce() {
            int ran;
            while(true){
                try {
                    ran=(int)Math.random()*10+1;
                    queue.put(1);
                    System.out.println("向队列插入一个元素，队列剩余空间："+(queueSize-queue.size()));
                    sleep(ran);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

Si lo ejecuta, encontrará que el programa no se bloquea y no se ejecuta, lo que confirma que la cola de bloqueo es segura para subprocesos, es decir, no habrá bloqueo de productor mientras que bloqueo de consumidor.