在应用中,我们常常需要 Thread 缓冲池来做一些事以提高程序的效率和并发性。本文演示了如何利用 Queue 这种数据结构实现一个简单的 Thread 缓冲池。
一个 Thread 缓冲池可以设计成以下这样:缓冲池由几个工作 Thread 和一个 Queue 组成, Client 负责把任务放到 Queue 里面( put 方法),而工作 Thread 就依次取出这些任务并执行它们( get 方法)。
Queue 的一个经典实现是使用一个循环数组(这个实现在很多数据结构的书上都有介绍),如一个大小为 size 的数组,这个循环数组可以被想象成首尾相连的一个环。 oldest 指向 Queue 中最老的数据所在的位置, next 指向下一个可以放新数据的位置。
放入一个新数据到 next 的位置后,需要更新 next : next = (next + 1) % size;
从 oldest 位置取出一个数据后,需要更新 oldest : oldest = (oldest + 1) % size;
当 oldest == next 的时候, Queue 为空,
当 (next + 1) % size == oldest 的时候, Queue 为满。
(注意:为了区分 Queue 为空和为满的情况,实际上 Queue 里面最多能放 size-1 个数据。)
因为这个 Queue 会同时被多个线程访问,需要考虑在这种情况下 Queue 如何工作。首先, Queue 需要是线程安全的,可以用 Java 里的 synchronized 关键字来确保同时只有一个 Thread 在访问 Queue.
我们还可以注意到当 Queue 为空的时候, get 操作是无法进行的;当 Queue 为满的时候, put 操作又是无法进行的。在多线程访问遇到这种情况时,一般希望执行操作的线程可以等待( block )直到该操作可以进行下去。比如,但一个 Thread 在一个空 Queue 上执行 get 方法的时候,这个 Thread 应当等待 (block) ,直到另外的 Thread 执行该 Queue 的 put 方法后,再继续执行下去。在 Java 里面, Object 对象的 wait(),notify() 方法提供了这样的功能。
把上面的内容结合起来,就是一个 SyncQueue 的类:
public class SyncQueue {
public SyncQueue(int size) {
_array = new Object[size];
_size = size;
_oldest = 0;
_next = 0;
}
public synchronized void put(Object o) {
while (full()) {
try {
wait();
} catch (InterruptedException ex) {
throw new ExceptionAdapter(ex);
}
}
_array[_next] = o;
_next = (_next + 1) % _size;
notify();
}
public synchronized Object get() {
while (empty()) {
try {
wait();
} catch (InterruptedException ex) {
throw new ExceptionAdapter(ex);
}
}
Object ret = _array[_oldest];
_oldest = (_oldest + 1) % _size;
notify();
return ret;
}
protected boolean empty() {
return _next == _oldest;
}
protected boolean full() {
return (_next + 1) % _size == _oldest;
}
protected Object [] _array;
protected int _next;
protected int _oldest;
protected int _size;
}
可以注意一下 get 和 put 方法中 while 的使用,如果换成 if 是会有问题的。这是个很容易犯的错误。 ;-)
在以上代码中使用了 ExceptionAdapter 这个类,它的作用是把一个 checked Exception 包装成 RuntimeException 。详细的说明可以参考我的避免在 Java 中使用 Checked Exception 一文。
接下来我们需要一个对象来表现 Thread 缓冲池所要执行的任务。可以发现 JDK 中的 Runnable interface 非常合适这个角色。
最后,剩下工作线程的实现就很简单了:从 SyncQueue 里取出一个 Runnable 对象并执行它。
public class Worker implements Runnable {
public Worker(SyncQueue queue) {
_queue = queue;
}
public void run() {
while (true) {
Runnable task = (Runnable) _queue.get();
task.run();
}
}
protected SyncQueue _queue = null;
}
下面是一个使用这个 Thread 缓冲池的例子:
// 构造 Thread 缓冲池
SyncQueue queue = new SyncQueue(10);
for (int i = 0; i < 5; i ++) {
new Thread(new Worker(queue)).start();
}
// 使用 Thread 缓冲池
Runnable task = new MyTask();
queue.put(task);
为了使本文中的代码尽可能简单,这个 Thread 缓冲池的实现是一个基本的框架。当使用到实际中时,一些其他功能也可以在这一基础上添加,比如异常处理,动态调整缓冲池大小等等。