09 | 队列：队列在线程池等有限资源池中的应用

队列的应用也非常广泛，特别是一些具有某些额外特性的队列，比如循环队列、阻塞队列、并发队列。它们在很多偏底层系统、框架、中间件的开发中，起着关键性的作用。比如高性能队列 Disruptor、Linux 环形缓存，都用到了循环并发队列；Java concurrent 并发包利用 ArrayBlockingQueue 来实现公平锁等。

 

如何设计队列？

基于数组的队列实现方法

队列需要两个指针：一个是 head 指针，指向队头；一个是 tail 指针，指向队尾。

你可以结合下面这幅图来理解。当 a、b、c、d 依次入队之后，队列中的 head 指针指向下标为 0 的位置，tail 指针指向下标为 4 的位置。调用两次出队操作之后，队列中 head 指针指向下标为 2 的位置，tail 指针仍然指向下标为 4 的位置。

     

随着不停地进行入队、出队操作，head 和 tail 都会持续往后移动。当 tail 移动到最右边，即使数组中还有空闲空间，也无法继续往队列中添加数据了。

出现这种情况的时候可以借鉴“数组”中删除数据时候的做法：数据搬移

当“出队”的时候仍然是最前面的元素出去，即head下标向后移动一位；当“入队”的时候需要检查，tail == n的时候，head是否为0，如果不为0说明此时队列中仍然有空闲位置，把队列中的数据整体向前移动即可 。

class Queue {
public:
	Queue(int num) :n(num) {
		data = new int[n];
	}
	~Queue() {
		delete data;
	}
	int head;
	int tail;
	int n;
	int *data;

	bool enqueue(int m)
	{
		if (tail == n) {
			if (head == 0)	return false;
			int l = 0;
			for (int i = head; i < tail; i++) {
				data[l++] = data[i];
			}
			tail -= head;
			head = 0;
		}
		data[tail++] = m;
		return true;
	}
};

 

基于链表的队列实现方法

同样需要head和tail指针，不过不需要顾及空间的拷贝了，直接去tail之后插入，pop出去head结点，当然要注意判断空处理。

 

循环队列

使用循环队列避免在队列中出现的数据移动。如图（1）

如何写出bug free的循环队列，注意两点：

• 什么条件下循环队列为空

当head == tail的时候，循环队列就为空。

• 什么条件下循环队列为满

当(tail + 1) % n == head时候，循环队列就为满了。当队列满时，图中的 tail 指向的位置实际上是没有存储数据的。所以，循环队列会浪费一个数组的存储空间。如图（2）

class Queue {
public:
	Queue(int num) :n(num) {
		data = new int[n];
	}
	~Queue() {
		delete data;
	}
	int head;
	int tail;
	int n;
	int *data;

	bool enqueue(int m){
		if ((tail + 1) % n == head)	return false;
		data[tail] = m;
		tail = (tail + 1) % n;
		return true;
	}

	bool dequeue(int m){
		if (head == tail)	return false;
		int ret = data[head];
		head = (head + 1) % n;
		return ret;
	}
};

 

阻塞队列和并发队列

前面讲的内容理论比较多，看起来很难跟实际的项目开发扯上关系。确实，队列这种数据结构很基础，平时的业务开发不大可能从零实现一个队列，甚至都不会直接用到。而一些具有特殊特性的队列应用却比较广泛，比如阻塞队列和并发队列。

阻塞队列

在队列为空的时候，从队头取数据会被阻塞。因为此时还没有数据可取，直到队列中有了数据才能返回；如果队列已经满了，那么插入数据的操作就会被阻塞，直到队列中有空闲位置后再插入数据，然后再返回。上述的定义就是一个“生产者 - 消费者模型”！我们可以使用阻塞队列，轻松实现一个“生产者 - 消费者模型”！

基于阻塞队列，我们还可以通过协调“生产者”和“消费者”的个数，来提高数据的处理效率。比如前面的例子，我们可以多配置几个“消费者”，来应对一个“生产者”。

 

并发队列

线程安全的队列叫作并发队列。

最简单直接的实现方式是直接在 enqueue()、dequeue() 方法上加锁，但是锁粒度大并发度会比较低，同一时刻仅允许一个存或者取操作。实际上，基于数组的循环队列，利用 CAS 原子操作，可以实现非常高效的并发队列。

 

问题解答：

• 线程池没有空闲线程时，新的任务请求线程资源时，线程池该如何处理？各种处理策略又是如何实现的呢？

第一种是非阻塞的处理方式，直接拒绝任务请求；另一种是阻塞的处理方式，将请求排队，等到有空闲线程时，取出排队的请求继续处理。

• 那如何存储排队的请求呢？

我们希望公平地处理每个排队的请求，先进者先服务，所以队列这种数据结构很适合来存储排队请求。

• 这两种实现方式对于排队请求又有什么区别呢？

基于链表的实现方式，可以实现一个支持无限排队的无界队列（unbounded queue），但是可能会导致过多的请求排队等待，请求处理的响应时间过长。所以，针对响应时间比较敏感的系统，基于链表实现的无限排队的线程池是不合适的；而基于数组实现的有界队列（bounded queue），队列的大小有限，所以线程池中排队的请求超过队列大小时，接下来的请求就会被拒绝，这种方式对响应时间敏感的系统来说，就相对更加合理。不过，设置一个合理的队列大小，也是非常有讲究的。队列太大导致等待的请求太多，队列太小会导致无法充分利用系统资源、发挥最大性能。

tips：队列可以应用在任何有限资源池中。对于大部分资源有限的场景，当没有空闲资源时，基本上都可以通过“队列”这种数据结构来实现请求排队。

 

课后思考：

• 除了线程池这种池结构会用到队列排队请求，你还知道有哪些类似的池结构或者场景中会用到队列的排队请求呢？

分布式应用中的消息队列，也是一种队列结构

• 今天讲到并发队列，关于如何实现无锁并发队列，网上有非常多的讨论。对这个问题，你怎么看呢？

考虑使用CAS实现无锁队列，则在入队前，获取tail位置，入队时比较tail是否发生变化，如果否，则允许入队，反之，本次入队失败。出队则是获取head位置，进行CAS。CAS（Compare And Swap）意为比较并且交换，CAS它是一个原子操作。