①队列包含固定长度的队列和不固定长度的队列
④ArrayBlockingQueue
②什么是可阻塞队列,阻塞队列的作用与实际应用,阻塞队列的实现原理。
阻塞队列是一个在队列基础上又支持了两个附加操作的队列。
2个附加操作:
- 支持阻塞的插入方法:队列满时,队列会阻塞插入元素的线程,直到队列不满。
- 支持阻塞的移除方法:队列空时,获取元素的线程会等待队列变为非空。
class BoundedBuffer {
final Lock lock = new ReentrantLock();
final Condition notFull = lock.newCondition();
final Condition notEmpty = lock.newCondition();
final Object[] items = new Object[100];
int putptr, takeptr, count;
public void put(Object x) throws InterruptedException {
lock.lock();
try {
while (count == items.length)
notFull.await();
items[putptr] = x;
if (++putptr == items.length) putptr = 0;
++count;
notEmpty.signal();
} finally {
lock.unlock();
}
}
public Object take() throws InterruptedException {
lock.lock();
try {
while (count == 0)
notEmpty.await();
Object x = items[takeptr];
if (++takeptr == items.length) takeptr = 0;
--count;
notFull.signal();
return x;
} finally {
lock.unlock();
}
}
}
③阻塞队列与Semaphore有些相似,但也不同,阻塞队列是一方存放数据,另一方释放数据,Semaphore通常则是由同一方设置和释放信号量。
④ArrayBlockingQueue
只有put方法和take方法才具有阻塞功能
⑤用3个空间的队列来演示阻塞队列的功能和效果。
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class BlockingQueueTest {
public static void main(String[] args) {
final BlockingQueue queue = new ArrayBlockingQueue(3);
for(int i=0;i<2;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() + "个数据");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
}
new Thread(){
public void run(){
while(true){
try {
//将此处的睡眠时间分别改为100和1000,观察运行结果
Thread.sleep(1000);
System.out.println(Thread.currentThread().getName() + "准备取数据!");
queue.take();
System.out.println(Thread.currentThread().getName() + "已经取走数据," + "队列目前有" + queue.size() + "个数据");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}.start();
}
}
结果:
Thread-1准备放数据!
Thread-1已经放了数据,队列目前有1个数据
Thread-0准备放数据!
Thread-0已经放了数据,队列目前有2个数据
Thread-1准备放数据!
Thread-1已经放了数据,队列目前有3个数据
Thread-0准备放数据!
Thread-1准备放数据!
Thread-2准备取数据!
Thread-0已经放了数据,队列目前有3个数据
Thread-2已经取走数据,队列目前有3个数据
Thread-0准备放数据!
Thread-2准备取数据!
Thread-2已经取走数据,队列目前有2个数据
Thread-1已经放了数据,队列目前有3个数据
Thread-1准备放数据!
Thread-2准备取数据!
Thread-0已经放了数据,队列目前有3个数据
Thread-2已经取走数据,队列目前有3个数据
Thread-0准备放数据!
Thread-2准备取数据!
Thread-2已经取走数据,队列目前有2个数据
Thread-1已经放了数据,队列目前有3个数据
Thread-1准备放数据!
Thread-2准备取数据!
Thread-2已经取走数据,队列目前有2个数据
Thread-0已经放了数据,队列目前有3个数据
Thread-0准备放数据!
Thread-2准备取数据!
Thread-2已经取走数据,队列目前有2个数据
Thread-1已经放了数据,队列目前有3个数据
Thread-1准备放数据!
Thread-2准备取数据!
。。。。。。。。
⑥用两个具有1个空间的队列来实现同步通知的功能。
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
/**
* 第一个线程:A.take()……..B.put()
* 第二个线程:B.take()……..A.put()
*/
public class BlockingQueueCommunication {
public static void main(String[] args) {
final Business business = new Business();
new Thread(new Runnable() {
public void run() {
for (int i = 1; i <= 3; i++) {
business.sub(i);
}
}
}).start();
for (int i = 1; i <= 3; i++) {
business.main(i);
}
}
static class Business {
BlockingQueue<Integer> queue1 = new ArrayBlockingQueue<Integer>(1);
BlockingQueue<Integer> queue2 = new ArrayBlockingQueue<Integer>(1);
//匿名构造函数,比任何构造函数先执行
{
try {
queue2.put(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/**
* 如果在方法头部上加了synchronized,则queue2进不去了,产生死锁
*/
public void sub(int i) {
try {
queue1.put(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int j = 1; j <= 3; j++) {
System.out.println("sub thread sequence of " + j + ",loop of " + i);
}
try {
queue2.take();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
/**
* 如果在方法头部上加了synchronized,则queue1进不去了,产生死锁
*/
public void main(int i) {
try {
queue2.put(1);
} catch (InterruptedException e) {
e.printStackTrace();
}
for (int j = 1; j <= 3; j++) {
System.out.println("main thread sequence of " + j + ",loop of " + i);
}
try {
queue1.take();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
结果:
sub thread sequence of 1,loop of 1
sub thread sequence of 2,loop of 1
sub thread sequence of 3,loop of 1
main thread sequence of 1,loop of 1
main thread sequence of 2,loop of 1
main thread sequence of 3,loop of 1
sub thread sequence of 1,loop of 2
sub thread sequence of 2,loop of 2
sub thread sequence of 3,loop of 2
main thread sequence of 1,loop of 2
main thread sequence of 2,loop of 2
main thread sequence of 3,loop of 2
sub thread sequence of 1,loop of 3
sub thread sequence of 2,loop of 3
sub thread sequence of 3,loop of 3
main thread sequence of 1,loop of 3
main thread sequence of 2,loop of 3
main thread sequence of 3,loop of 3
⑦
Java 7 提供了7个阻塞队列,如下
a:ArrayBlockingQueue 数组结构组成的有界阻塞队列。
此队列按照先进先出(FIFO)的原则对元素进行排序,但是默认情况下不保证线程公平的访问队列,即如果队列满了,那么被阻塞在外面的线程对队列访问的顺序是不能保证线程公平(即先阻塞,先插入)的。
b:LinkedBlockingQueue一个由链表结构组成的有界阻塞队列
此队列按照先出先进的原则对元素进行排序
c:PriorityBlockingQueue支持优先级的无界阻塞队列
d:DelayQueue支持延时获取元素的无界阻塞队列,即可以指定多久才能从队列中获取当前元素
e:SynchronousQueue不存储元素的阻塞队列,每一个put必须等待一个take操作,否则不能继续添加元素。并且他支持公平访问队列。
f:LinkedTransferQueue由链表结构组成的无界阻塞TransferQueue队列。相对于其他阻塞队列,多了tryTransfer和transfer方法
- transfer方法,如果当前有消费者正在等待接收元素(take或者待时间限制的poll方法),transfer可以把生产者传入的元素立刻传给消费者。如果没有消费者等待接收元素,则将元素放在队列的tail节点,并等到该元素被消费者消费了才返回。
- tryTransfer方法,用来试探生产者传入的元素能否直接传给消费者。,如果没有消费者在等待,则返回false。和上述方法的区别是该方法无论消费者是否接收,方法立即返回。而transfer方法是必须等到消费者消费了才返回。
g:LinkedBlockingDeque链表结构的双向阻塞队列,优势在于多线程入队时,减少一半的竞争。