队列Queue2

最新推荐文章于 2023-10-08 11:21:28 发布

一介烂人ぶ谩骂随心

最新推荐文章于 2023-10-08 11:21:28 发布

阅读量106

点赞数 3

文章标签： java 开发语言

本文链接：https://blog.csdn.net/tiger_root/article/details/126820397

版权

Java针对队列提供的实现

接口定义及常用方法

public interface Queue<E> extends Collection<E>

        boolean add(E e); 在队尾添加数据

        boolean offer(E e); 在LinkedList中就是使用add提供的实现

         E remove(); 删除队列头部的数据，同时返回删除的数据

        E poll();

        E element(); 获取队列头部的数据，并不会执行删除操作

        E peek();

队列主要分为阻塞和非阻塞，有界和无界，单向链表和双向链表之分

阻塞和非阻塞

阻塞队列
        - 入列(添加元素)时，如果元素数量超过队列总数，会进行等待（阻塞），待队列的中的元素出列后，元素数量未超过队列总数时，就会解除阻塞状态，进而可以继续入列；
        - 出列(删除元素)时，如果队列为空的情况下，也会进行等待（阻塞），待队列有值的时候即会解除阻塞状态，进而继续出列；

阻塞队列的好处是可以防止队列容器溢出；只要满了就会进行阻塞等待；也就不存在溢出的情况；只要是阻塞队列，都是线程安全的；

非阻塞队列
        - 不管出列还是入列，都不会进行阻塞，
        - 入列时，如果元素数量超过队列总数，则会抛出异常，
        - 出列时，如果队列为空，则取出空值；
一般情况下，非阻塞式队列使用的比较少，一般都用阻塞式的对象比较多；阻塞和非阻塞队列在使用上的最大区别就是阻塞队列提供了以下2个方法：
        - 出队阻塞方法： take()
        - 入队阻塞方法： put()

阻塞队列
        1、DelayQueue 一个支持延时获取元素的无界阻塞队列
        2、LinkedTransferQueue一个由链表结构组成的无界阻塞队列。
        3、ArrayBlockingQueue有界队列，阻塞式,初始化时必须指定队列大小，且不可改变；底层由数组实现；
        4、SynchronousQueue最多只能存储一个元素，每一个put操作必须等待一个take操作，否则不能继续添加元素
        5、PriorityBlockingQueue一个带优先级的队列，而不是先进先出队列。元素按优先级顺序被移除，而且它也是无界的，也就是没有容量上限，虽然此队列逻辑上是无界的，但是由于资源被耗尽，所以试图执行添加操作可能会导致 OutOfMemoryError 错误；

非阻塞队列
        1、ConcurrentLinkedQueue 单向链表结构的无界并发队列, 非阻塞队列，由CAS实现线程安全，内部基于节点实现
        2、ConcurrentLinkedDeque双向链表结构的无界并发队列, 非阻塞队列，由CAS实现线程安全
        3、PriorityQueue 内部基于数组实现，线程不安全的队列

有界和无界

有界：有界限，大小长度受限制
无界：理论上来说无限大小，其实说是无限大小，其实是有界限的，只不过超过界限时就会进行扩容，就行ArrayList 一样，在内部动态扩容

Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Deque接口。

双向队列接口Deque

public interface Deque<E> extends Queue<E> {
        void addFirst(E e); 在队列头部添加数据

        boolean offerFirst(E e);
    void addLast(E e); 在队尾添加数据

boolean offerLast(E e);
E removeFirst(); 从对头中删除数据，同时返回删除的数据

E pollFirst();
E removeLast(); 从队尾伤处数据

E pollLast();
   E getFirst(); 从对头获取数据
E peekFirst();
E getLast(); 从队尾获取数据

E peekLast();

}

Queue的实现

没有实现的阻塞接口的LinkedList：实现了java.util.Queue接口和java.util.AbstractQueue接口

内置的不阻塞队列： PriorityQueue 和 ConcurrentLinkedQueue

PriorityQueue类实质上维护了一个有序列表。加入到Queue中的元素根据它们的天然排序（通过其java.util.Comparable实现）或者根据传递给构造函数的java.util.Comparator实现来定位。
ConcurrentLinkedQueue是基于链接节点的、CAS实现线程安全的队列。并发访问不需要同步。因为它在队列的尾部添加元素并从头部删除它们，所以只要不需要知道队列的大小，ConcurrentLinkedQueue对公共集合的共享访问就可以工作得很好。收集关于队列大小的信息会很慢，需要遍历队列。

实现阻塞接口的：java.util.concurrent中加入了 BlockingQueue 接口和五个阻塞队列类。它实质上就是一种带有一点扭曲的FIFO数据结构。不是立即从队列中添加或者删除元素，线程执行操作阻塞，直到有空间或者元素可用。
五个队列所提供的各有不同：
　　ArrayBlockingQueue ：一个由数组支持的有界队列。
　　LinkedBlockingQueue ：一个由链接节点支持的可选有界队列。
　　PriorityBlockingQueue ：一个由优先级堆支持的无界优先级队列。
　　DelayQueue ：一个由优先级堆支持的、基于时间的调度队列。
　　SynchronousQueue ：一个利用 BlockingQueue 接口的简单聚集（rendezvous）机制。

add	增加一个元索	如果队列已满，则抛出一个IllegalStateException异常
offer	添加一个元素并返回true	如果队列已满，则返回false
remove	移除并返回队列头部的元素	如果队列为空，则抛出一个NoSuchElementException异常
poll	移除并返问队列头部的元素	如果队列为空，则返回null
element	返回队列头部的元素	如果队列为空，则抛出一个NoSuchElementException异常
peek	返回队列头部的元素	如果队列为空，则返回null
put	添加一个元素	如果队列满，则阻塞
take	移除并返回队列头部的元素	如果队列为空，则阻塞

import java.util.LinkedList;
import java.util.Queue;

public class Test1 {
	public static void main(String[] args) {
		Queue<Integer> list=new LinkedList<>();
		list.add(123);
		list.add(345);
		list.add(567);
		list.offer(666);
		
		System.out.println(list.remove());
		System.out.println(list.poll());
		
		System.out.println(list.element());
		System.out.println(list.peek());
		System.out.println();
		
		list.forEach(System.out::println);
	}
}

阻塞队列的操作可以根据它们的响应方式分为以下三类：add、removee和element操作在你试图为一个已满的队列增加元素或从空队列取得元素时抛出异常。当然，在多线程程序中，队列在任何时间都可能变成满的或空的，所以你可能想使用offer、poll、peek方法。这些方法在无法完成任务时只是给出一个出错示而不会抛出异常。

注意：poll和peek方法出错进返回null。因此，向队列中插入null值是不合法的

最后有阻塞操作put和take。put方法在队列满时阻塞，take方法在队列空时阻塞。

LinkedBlockingQueue的容量是没有上限的（说的不准确，在不指定时容量为Integer.MAX_VALUE，不要然的话在put时怎么会受阻呢），但是也可以选择指定其最大容量，它是基于链表的队列，此队列按 FIFO先进先出排序元素。

ArrayBlockingQueue在构造时需要指定容量，并可以选择是否需要公平性，如果公平参数被设置true，等待时间最长的线程会优先得到处理（其实就是通过将ReentrantLock设置为true来达到这种公平性的：即等待时间最长的线程会先操作）。通常，公平性会使你在性能上付出代价，只有在的确非常需要的时候再使用它。它是基于数组的阻塞循环队列，此队列按 FIFO（先进先出）原则对元素进行排序。

PriorityBlockingQueue是一个带优先级的队列，而不是先进先出队列。元素按优先级顺序被移除，该队列也没有上限（看了一下源码，PriorityBlockingQueue是对 PriorityQueue的再次包装，是基于堆数据结构的，而PriorityQueue是没有容量限制的，与ArrayList一样，所以在优先阻塞队列上put时是不会受阻的。虽然此队列逻辑上是无界的，但是由于资源被耗尽，所以试图执行添加操作可能会导致 OutOfMemoryError），但是如果队列为空，那么取元素的操作take就会阻塞，所以它的检索操作take是受阻的。另外，往入该队列中的元素要具有比较能力。

DelayQueue（基于PriorityQueue来实现的）是一个存放Delayed 元素的无界阻塞队列，只有在延迟期满时才能从中提取元素。该队列的头部是延迟期满后保存时间最长的 Delayed 元素。如果延迟都还没有期满，则队列没有头部，并且poll将返回null。当一个元素的 getDelay(TimeUnit.NANOSECONDS) 方法返回一个小于或等于零的值时，则出现期满，poll就以移除这个元素了。此队列不允许使用 null 元素。

import java.util.Deque;
import java.util.LinkedList;

public class TestLinkedList {
	public static void main(String[] args) {
		Deque<Integer> deque=new LinkedList<>();
		deque.addFirst(99);
		deque.addFirst(88);
		deque.addLast(77);
		
		deque.forEach(System.out::println);
		
		System.out.println(deque.removeLast());
		System.out.println();
		deque.forEach(System.out::println);
	}
}

import java.util.Comparator;
import java.util.Iterator;
import java.util.PriorityQueue;
import java.util.Random;

public class TestPriorityQueue {
	public static void main(String[] args) {
//		PriorityQueue<Integer> queue=new PriorityQueue<>(new Comparator<Integer>() {
//			@Override
//			public int compare(Integer o1, Integer o2) {
//				System.out.println("compare...");
//				return o1-o2;
//			}
//		});
		PriorityQueue<Integer> queue=new PriorityQueue<>();
//		queue.add(66);
//		queue.add(99);
//		queue.add(88);
		
		Random r=new Random();
		int p1=0;
		for(int i=0;i<10;i++) {
			p1=r.nextInt(100);
			queue.add(p1);
			System.out.print(p1+"\t");
		}
		System.out.println();
		
		Iterator<Integer> it=queue.iterator();
		while(it.hasNext())
			System.out.print(it.next()+"\t");
		System.out.println();
		while(!queue.isEmpty())
			System.out.print(queue.remove()+"\t");
		
//		queue.forEach(System.out::println);
//		System.out.println(queue.remove());
//		System.out.println(queue.remove());
//		System.out.println(queue.remove());
//		System.out.println(queue.size());
	}
}

import java.util.Random;
import java.util.concurrent.SynchronousQueue;

public class Test1 {
	public static void main(String[] args) {
		SynchronousQueue<Object> queue = new SynchronousQueue<>();
//		for (int k = 0; k < 5; k++) {
			new Thread(() -> {
				Random r = new Random();
				for (int i = 0; i < 20; i++) {
//					System.out.println(Thread.currentThread().getName() + "开始生产......");
					try {
						queue.put(i + "-" + r.nextInt(50)+" "+Thread.currentThread().getName());
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
//					System.out.println(Thread.currentThread().getName() + "生产结束......");
				}
			}, "producer-").start();

			new Thread(() -> {
				for (int i = 0; i < 20; i++) {
//					System.out.println(Thread.currentThread().getName() + "开始消费......");
					try {
						Object res = queue.take();
						System.out.println(res);
					} catch (InterruptedException e) {
						e.printStackTrace();
					}
//					System.out.println(Thread.currentThread().getName() + "消费结束......");
				}
			}, "consumer-").start();
//		}
	}
}