Java 谈谈阻塞队列

什么是阻塞队列

阻塞队列，顾名思义，首先它是一个队列，其次他是可以阻塞的。阻塞简单的说就是在后面等着排队。

而一个阻塞队列在数据结构中所起的作用大致如图所示：

• 当阻塞队列是空时，从队列中获取元素的操作将会被阻塞。
• 当阻塞队列是满时，往队列中添加元素的操作将会被阻塞.。

同样，试图往已满的阻塞队列中添加新元素的线程同样也会被阻塞，知道其他线程从队列中移除一个或者多个元素或者全清空队列后使队列重新变得空闲起来并后续新增。

为什么要有阻塞队列？

在多线程领域：所谓阻塞，在某些情况下会挂起线程(即线程阻塞)，一旦条件满足，被挂起的线程优惠被自动唤醒。

有什么好处？

好处是我们不需要关心什么时候需要阻塞线程,什么时候需要唤醒线程,因为BlockingQueue都一手给你包办好了。
在 java.util.concurrent 包 发布以前，在多线程环境下，我们每个程序员都必须自己去控制这些细节，尤其还要兼顾效率和线程安全，而这会给我们的程序带来不小的复杂度。

用在哪里？

• 生产者消费者模式
• 线程池
• 消息中间件

阻塞队列架构

• ArrayBlockingQueue：由数组结构组成的有界阻塞队列。
• LinkedBlockingDeque：由链表结构组成的有界(但大小默认值Integer.MAX_VALUE)阻塞 队列。
• PriorityBlockingQueue：支持优先级排序的无界阻塞队列。
• DelayQueue：使用优先级队列实现的延迟无界阻塞队列。
• SynchronousQueue：不存储元素的阻塞队列，也即是单个元素的队列。
• LinkedTransferQueue：由链表结构组成的无界阻塞队列。
• LinkedBlockingDeque：由了解结构组成的双向阻塞队列。

核心方法

进一步说明

抛出异常	阻塞队列满时，再往队列里面 add 插入元素会抛 IllegalStateException: Queue full 当阻塞队列空时，再往队列 remove 元素时候回抛出 NoSuchElementException
特殊值	插入方法，成功返回 true，失败返回 false 移除方法，成功返回元素，队列里面没有就返回 null
一直阻塞	当阻塞队列满时，生产者继续往队列里面 put 元素，队列会一直阻塞直到put数据or响应中断退出 当阻塞队列空时，消费者试图从队列 take 元素，队列会一直阻塞消费者线程直到队列可用
超时退出	当阻塞队列满时，队列会阻塞生产者线程一定时间，超过后限时后生产者线程就会退出

抛出异常

add

public class BlockingQueueDemo {
	public static void main(String[] args) {
		// 长度为 1 阻塞队列
		BlockingQueue<String> bq = new ArrayBlockingQueue<>(1);
		System.out.println("=======添加异常========");
		System.out.println("add："+bq.add("a"));
		System.out.println("add："+bq.add("a"));
		
	}
}

运行结果

remove

public class BlockingQueueDemo {
	public static void main(String[] args) {
		// 长度为 1 阻塞队列
		BlockingQueue<String> bq = new ArrayBlockingQueue<>(1);
		System.out.println("=======删除异常========");
		System.out.println("add："+bq.add("a"));
		System.out.println("remove："+bq.remove());
		System.out.println("remove："+bq.remove());
		
	}
}

运行结果

element

public class BlockingQueueDemo {
	public static void main(String[] args) {
		// 长度为 1 阻塞队列
		BlockingQueue<String> bq = new ArrayBlockingQueue<>(1);
		System.out.println("=======查看异常========");
		System.out.println("add："+bq.add("a"));
		System.out.println("element："+bq.element());
		System.out.println("remove："+bq.remove());
		System.out.println("element："+bq.element());
		
	}
}

运行结果

特殊值

offer

public class BlockingQueueDemo {
	public static void main(String[] args) {
		// 长度为 1 阻塞队列
		BlockingQueue<String> bq = new ArrayBlockingQueue<>(1);
		System.out.println("=======offer========");
		System.out.println("offer："+bq.offer("a"));
		System.out.println("offer："+bq.offer("a"));
		
	}
}

运行结果

poll

public class BlockingQueueDemo {
	public static void main(String[] args) {
		// 长度为 1 阻塞队列
		BlockingQueue<String> bq = new ArrayBlockingQueue<>(1);
		System.out.println("=======poll========");
		System.out.println("offer："+bq.offer("a"));
		System.out.println("poll："+bq.poll());
		System.out.println("poll："+bq.poll());
		
	}
}

运行结果

peek

public class BlockingQueueDemo {
	public static void main(String[] args) {
		// 长度为 1 阻塞队列
		BlockingQueue<String> bq = new ArrayBlockingQueue<>(1);
		System.out.println("=======peek========");
		System.out.println("offer："+bq.offer("a"));
		System.out.println("peek："+bq.peek());
		System.out.println("poll："+bq.poll());
		System.out.println("peek："+bq.peek());
		
	}
}

运行结果

阻塞

put

public class BlockingQueueDemo {
	public static void main(String[] args) {
		// 长度为 1 阻塞队列
		BlockingQueue<String> bq = new ArrayBlockingQueue<>(1);
		System.out.println("=======put========");
		try {
			bq.put("a");
			bq.put("a");
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
	}
}

运行结果

take

public class BlockingQueueDemo {
	public static void main(String[] args) {
		// 长度为 1 阻塞队列
		BlockingQueue<String> bq = new ArrayBlockingQueue<>(1);
		System.out.println("=======take========");
		try {
			bq.put("a");
			bq.take();
			bq.take();
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
	}
}

运行结果

超时(功能最强)

offer(e,time,unit)

public class BlockingQueueDemo {
	public static void main(String[] args) {
		// 长度为 1 阻塞队列
		BlockingQueue<String> bq = new ArrayBlockingQueue<>(1);
		System.out.println("=======offer(e,time,unit)========");
		try {
			System.out.println(bq.offer("a", 1L,TimeUnit.SECONDS));
			System.out.println(bq.offer("a", 1L,TimeUnit.SECONDS));
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
	}
}

运行结果

poll(time,unit)

public class BlockingQueueDemo {
	public static void main(String[] args) {
		// 长度为 1 阻塞队列
		BlockingQueue<String> bq = new ArrayBlockingQueue<>(1);
		System.out.println("=======poll(time,unit)========");
		try {
			System.out.println(bq.offer("a", 1L,TimeUnit.SECONDS));
			System.out.println(bq.poll( 1L,TimeUnit.SECONDS));
			System.out.println(bq.poll( 1L,TimeUnit.SECONDS));
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
	}
}

运行结果

SynchronousQueue

不存储元素的阻塞队列，也即是单个元素的队列。创建其对象时候需要可以传一个 boolean 类型参数，用来告诉 java 这个队列是公平的还是非公平的。

示例

public class SynchronousQueueDemo {
	public static void main(String[] args) {
		// 构造的时候可以传一个参数 fair，true 公平，false 非公平. 默认 false
		SynchronousQueue<String> syncQueue = new SynchronousQueue<>(false);
		
		new Thread(()->{
			try {
				System.out.println(Thread.currentThread().getName()+" put 1");
				syncQueue.put("1");

				System.out.println(Thread.currentThread().getName()+" put 2");
				syncQueue.put("2");

				System.out.println(Thread.currentThread().getName()+" put 3");
				syncQueue.put("3");
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		},"A").start();
		
		
		new Thread(()->{
			try {
				//暂停1秒取
				Thread.sleep(1000);
				System.out.println(Thread.currentThread().getName()+" get "+syncQueue.take());
				//暂停1秒取
				Thread.sleep(1000);
				System.out.println(Thread.currentThread().getName()+" get "+syncQueue.take());
				//暂停1秒取
				Thread.sleep(1000);
				System.out.println(Thread.currentThread().getName()+" get "+syncQueue.take());
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		},"A").start();
	}
}

运行结果