JDK5新特性之线程阻塞队列(四)
来源:程序员人生 发布时间:2014-11-19 08:42:32 阅读次数:2177次
1. 阻塞队列和普通队列:
队列是1种基本的数据类型,其典型特点是先进先出。
阻塞队列和普通队列的区分在于:
当队列为空时,从队列中获得元素的线程会被阻塞,直到其他的线程往空的队列里插入新的元素;
当队列是满的时,往队列里添加元素的操作会被阻塞,直到其他的线程从队列移除1个或多个元素;
上图中:线程1往阻塞队列里添加元素,而线程2从阻塞队列里移除元素
/**
* 阻塞队列的简单实现
*/
public class BlockingQueue<T> {
private List<T> queue = new LinkedList<T>();
private int limit = 10;
public BlockingQueue(){
}
public BlockingQueue(int limit) {
this.limit = limit;
}
// 入队
public synchronized void enqueue(T obj) throws InterruptedException {
while (this.queue.size() == this.limit) {
wait();
}
if (this.queue.size() == 0) {
notifyAll();
}
this.queue.add(obj);
}
// 出队
public synchronized Object dequeue() throws InterruptedException {
while (this.queue.size() == 0) {
wait();
}
if (this.queue.size() == this.limit) {
notifyAll();
}
return this.queue.remove(0);
}
}
2. API实现:
BlockingQueue是1个接口,有以下实现类:
1. ArrayBlockQueue:1个由数组支持的有界阻塞队列,此队列遵守先进先出原则排序,创建其对象必须明确大小。
2. LinkedBlockQueue:1个可改变大小的阻塞队列,此队列遵守先进先出原则排序,创建其对象没有明确大小,并发程序中,性能稍差。
3. PriorityBlockingQueue: 类似LinkedBlockQueue,但其所含对象的排序不是先进先出,而是根据对象的自然排序顺序或构造函数所带的Comparator决定
4. SynchronousQueue:同步队列, 每插入1个必须等待另外一个线程移除。
下面代码用3个空间的队列来演示阻塞队列的功能和效果。
public class BlockingQueueTest {
public static void main(String[] args) {
// 阻塞队列类: 队列中可以存3个数据
final BlockingQueue<Integer> queue = new ArrayBlockingQueue<Integer>(3);
// 开启3个线程不断的存数据
for (int i = 0; i < 3; i++) {
new Thread() {
public void run() {
while (true) {
try {
Thread.sleep((long) Math.random() * 1000);
System.out.println(Thread.currentThread().getName() + " 准备放数据!");
queue.put(1); // 往队列中存数据
System.out.println(Thread.currentThread().getName()
+ " 已放了数据,队列目前有: " + queue.size() + " 个数据!");
Thread.sleep(1000);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}.start();
}
// 开启1个线程不断的取数据
new Thread() {
public void run() {
while (true) {
try {
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + " 准备取数据!");
queue.take(); // 从队列中取数据
System.out.println(Thread.currentThread().getName()
+ " 已取走数据,队列目前有: " + queue.size() + " 个数据!");
} catch (Exception e) {
e.printStackTrace();
}
}
}
}.start();
}
}
Thread⑴ 准备放数据!
Thread⑴ 已放了数据,队列目前有: 1 个数据!
Thread-0 准备放数据!
Thread-0 已放了数据,队列目前有: 2 个数据!
Thread⑵ 准备放数据!
Thread⑵ 已放了数据,队列目前有: 3 个数据!
Thread⑶ 准备取数据!
Thread⑶ 已取走数据,队列目前有: 2 个数据!
Thread⑴ 准备放数据!
Thread⑴ 已放了数据,队列目前有: 3 个数据!
Thread-0 准备放数据!
Thread⑵ 准备放数据!
Thread⑶ 准备取数据!
Thread⑶ 已取走数据,队列目前有: 2 个数据!
Thread-0 已放了数据,队列目前有: 3 个数据!
Thread⑴ 准备放数据!
Thread-0 准备放数据!
Thread⑶ 准备取数据!
Thread⑶ 已取走数据,队列目前有: 2 个数据!
Thread⑵ 已放了数据,队列目前有: 3 个数据!
3. 阻塞队列实现同步通讯
http://www.wfuyu.com/cxyms/题:子线程打印2行信息,然后主线程打印4行信息,循环各打印5次
public class BlockingQueueCommunication {
public static void main(String[] args) throws Exception {
final Business business = new Business();
// 子线程循环履行5次
new Thread(new Runnable() {
@Override
public void run() {
for (int i = 1; i <= 5; i++) {
try {
business.sub(i);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}).start();
// 主线程循环履行5次
for (int i = 1; i <= 5; i++) {
business.main(i);
}
}
static class Business {
// 阻塞子线程的队列,里面只能有1个数据, 超了就会阻塞
BlockingQueue<Integer> subQueue = new ArrayBlockingQueue<Integer>(1);
// 阻塞主线程的队列,里面只能有1个数据, 超了就会阻塞
BlockingQueue<Integer> mainQueue = new ArrayBlockingQueue<Integer>(1);
// 这是1个匿名的构造方法,创建对象的时候就会调用它
{
try {
System.out.println("我履行了,1上来就把main queue中放了1个数据");
mainQueue.put(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public void sub(int i) throws Exception {
subQueue.put(1);
for (int j = 0; j <= 1; j++) {
System.out.println("sub thread sequence of " + j + " ,loop of " + i);
}
mainQueue.take(); // main线程释放阻塞,开始运行
}
public void main(int i) throws Exception {
mainQueue.put(1);
for (int j = 0; j <= 3; j++) {
System.out.println("main thread sequence of " + j + " ,loop of " + i);
}
subQueue.take(); // sub线程释放阻塞,开始运行
}
}
}
生活不易,码农辛苦
如果您觉得本网站对您的学习有所帮助,可以手机扫描二维码进行捐赠