Java常用队列总结

1、ArrayBlockingQueue阻塞队列

• 什么情况下，我们会使用阻塞队列: 多线程并发处理，线程池!
• 添加、移除

四组API

• 1、抛出异常
• 2、不会抛出异常
• 3、阻塞等待
• 4、超时等待

package bq;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

/**
 * @ProjectName: www-ES-Api
 * @Package: bq
 * @ClassName: BLockingQueueTest
 * @Author: 125827
 * @Description: BLockingQueue
 * @Date: 1/12/2022 12:23 AM
 * @Version: 1.0
 */
public class BlockingQueueTest {
    
    
    public static void main(String[] args) throws InterruptedException {
    
    
        QueueTest3();
    }
    /** 抛出异常 */
    public static void ExceptionQueue(){
    
    
        BlockingQueue queue = new ArrayBlockingQueue<>(3);
        boolean a = queue.add("A");
        boolean b = queue.add("B");
        boolean c = queue.add("S");
        System.out.println(a+"---"+b+"---"+c);
        /** 队首无元素时，抛出异常java.util.NoSuchElementException*/
        System.out.println(queue.element());
        /** 元素个数超过队列长度，则报 java.lang.IllegalStateException: Queue full */
        Object remove = queue.remove("B");
        System.out.println(remove);
        System.out.println(queue.remove()+"---"+queue.remove());
        /** 删除时队列为空，返回java.util.NoSuchElementException
        queue.remove(); */
    }
    /** 不抛出异常，有返回值 */
    public static void QueueTest1(){
    
    
        BlockingQueue queue = new ArrayBlockingQueue<>(3);
        boolean a = queue.offer("A");
        boolean b = queue.offer("B");
        boolean c = queue.offer("S");
        System.out.println(a+"---"+b+"---"+c);
        System.out.println(queue.offer("c"));
        /** 元素个数超过队列长度，不抛出异常 ,直接返回 false*/
        Object remove = queue.poll();
        System.out.println(remove);
        System.out.println(queue.poll()+"---"+queue.poll());
        /** 删除时队列为空，不抛出异常 ,直接返回null*/
        System.out.println(queue.poll());
        /** 队首无元素时，不抛出异常 ,直接返回null */
        System.out.println(queue.peek());
    }
    /** 等待，阻塞，并一直阻塞 */
    public static void QueueTest2() throws InterruptedException {
    
    
        BlockingQueue queue = new ArrayBlockingQueue<>(3);
        queue.put("A");
        queue.put("B");
        queue.put("S");
        // queue.put("c");
        /** 元素个数超过队列长度，阻塞 */
        Object remove = queue.take();
        System.out.println(remove);
        System.out.println(queue.take()+"---"+queue.take());
        /** 删除时队列为空，阻塞*/
        // System.out.println(queue.take());
    }
    /** 阻塞，超时等待 */
    public static void QueueTest3() throws InterruptedException {
    
    
        BlockingQueue queue = new ArrayBlockingQueue<>(3);
        boolean a = queue.offer("A");
        boolean b = queue.offer("B");
        boolean c = queue.offer("S");
        System.out.println(a+"---"+b+"---"+c);
        System.out.println(queue.offer("c",2, TimeUnit.SECONDS));
        /** 元素个数超过队列长度，不抛出异常 ,超时等待两秒，返回 false*/
        Object remove = queue.poll();
        System.out.println(remove);
        System.out.println(queue.poll()+"---"+queue.poll());
        /** 删除时队列为空，不抛出异常 ,超时等待两秒，返回null*/
        System.out.println(queue.poll(2,TimeUnit.SECONDS));
    }
}

2、SynchronousQueue同步队列

• 没有容量，进去一个元素，必须等待取出来之后，才能再往里面放一个元素
• put、 take

package bq;

import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.TimeUnit;
/**
 * @ProjectName: www-ES-Api
 * @Package: bq
 * @ClassName: SynchronousQueueTest
 * @Author: 125827
 * @Description: SynchronousQueue
 * @Date: 1/12/2022 1:23 AM
 * @Version: 1.0
 */
public class SynchronousQueueTest {
    
    
    public static void main(String[] args) {
    
    
        SynchronousQueue<String> queue = new SynchronousQueue<>();
        new Thread(()->{
    
    
            try {
    
    
                System.out.println(Thread.currentThread().getName()+"put 1");
                queue.put("1");
                System.out.println(Thread.currentThread().getName()+"put 2");
                queue.put("2");
                System.out.println(Thread.currentThread().getName()+"put 3");
                queue.put("3");
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
        },"A").start();
        new Thread(()->{
    
    
            try {
    
    
                TimeUnit.SECONDS.sleep(3);
                System.out.println(Thread.currentThread().getName()+"take 1");
                queue.take();
                System.out.println(Thread.currentThread().getName()+"take 2");
                queue.take();
                System.out.println(Thread.currentThread().getName()+"take 3");
                queue.take();
            } catch (InterruptedException e) {
    
    
                e.printStackTrace();
            }
        },"B").start();
    }
}