java队列 Queue

队列是一种特殊的线性表，它只允许在表的前端进行删除操作，而在表的后端进行插入操作。

顶级接口为java.util.queue. 

java.util包中，java.util.concurrent包中有多种实现。其简易类图如下：

       在Java并发包中提供了两种类型的队列，非阻塞队列与阻塞队列，它们都是线程安全的（即不能有一个以上的线程同时对队列进行入队或者出队操作），无需担心在多线程并发环境所带来的不可预知的问题。阻塞与否在于是否有界，也就是在初始化时有没有给它一个默认的容量大小。

       对于阻塞有界队列来讲，如果队列满了的话，则任何线程都会阻塞不能进行入队操作，反之队列为空的话，则任何线程都不能进行出队操作。

       对于非阻塞无界队列来讲则不会出现队列满或者队列空的情况。它们俩都保证线程的安全性。

非阻塞队列：

• ConcurrentLinkedQueue：是一个基于链接节点的无界线程安全队列(java队列ConcurentLinkedQueue)
• PriorityQueue：是一个基于数组实现的队列

阻塞队列：

• ArrayBlockingQueue：一个由数组结构组成的有界阻塞队列。(java队列ArrayBlockingQueue)
• LinkedBlockingQueue：一个由链表结构组成的有界阻塞队列。 
• PriorityBlockingQueue：一个支持优先级排序的无界阻塞队列。 
• DealyQueue：一个使用优先级队列实现的无界阻塞队列。 
• SynchronousQueue：一个不存储元素的阻塞队列。 
• LinkedTransferQueue：一个由链表结构组成的无界阻塞队列。 
• LinkedBlockingDeque：一个由链表结构组成的双向阻塞队列。 

源码如下：

package java.util;
public interface Queue<E> extends Collection<E> {
    boolean add(E e);
    boolean offer(E e);
    E remove();
    E poll();
    E element();
    E peek();
}

 

------------------------自己实现的一个阻塞队列----------------------------------------------------------------------------

import java.util.ArrayList;
import java.util.List;

/**
 * @author Qiaofan
 * @create 2018-10-10 16:31
 * 自定义线程安全的阻塞队列
 **/
public class MyBlockingQueue {
    public MyBlockingQueue(Integer maxSize) {
        this.maxSize = maxSize;
        myQueue = new ArrayList<>(maxSize);
        System.out.println("队列初始化,池大小"+maxSize);
    }
    //队列大小
    private Integer maxSize;
    
    private List<String> myQueue;

    //自定义对象锁
    private  Object lock = new Object();

    /**
     * 出队方法
     */
    public void get(){
        synchronized(lock) {
            try {
                if(myQueue.size() == 0){
                    System.out.println("队列空了,线程"+Thread.currentThread().getName()+"等待...");
                    lock.wait();
                }else{
                    String str=this.myQueue.get(0);
                    myQueue.remove(0);
                    System.out.println("线程"+Thread.currentThread().getName()+"获取元素："+str);
                }
                lock.notifyAll();
            }catch(InterruptedException e){
                e.printStackTrace();
            }
        }
    }

    /**
     * 入队方法
     * @param str
     */
    public void put(String str){
        synchronized (lock){
            try {
                if(myQueue.size() == maxSize){
                    System.out.println("队列满了，线程"+Thread.currentThread().getName()+"等待...");
                    lock.wait();
                }else{
                    System.out.println("线程"+Thread.currentThread().getName()+"添加元素："+str);
                    myQueue.add(str);
                }
                lock.notifyAll();
            }catch(InterruptedException e){
                e.printStackTrace();
            }

        }
    }

}

测试的main方法

public static void main(String[] args){
        MyBlockingQueue myBlockingQueue = new MyBlockingQueue(10);
 
        Thread t3= new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    for (int i = 0; i < 10; i++) {
                        myBlockingQueue.put("T3-"+i);
                        Thread.sleep(200);
                    }
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        },"T3-");
 
        Thread t4= new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    for (int i = 0; i < 10; i++) {
                        myBlockingQueue.put("T4-"+i);
                        Thread.sleep(200);
                    }
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        },"T4-");
 
        Thread t2= new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    while (true){
                        myBlockingQueue.get();
                        Thread.sleep(100);
                    }
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        },"T2-");
 
        Thread t1= new Thread(new Runnable() {
            @Override
            public void run() {
                try{
                    while (true){
                        myBlockingQueue.get();
                        Thread.sleep(100);
                    }
                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        },"T1-");
 
        t3.start();
        t4.start();
        t1.start();
        t2.start();
}

 

https://www.cnblogs.com/demingblog/p/6474865.html