• 转: 【Java并发编程】之二十一:并发新特性—阻塞队列和阻塞栈(含代码)


    转载请注明出处:http://blog.csdn.net/ns_code/article/details/17511147


    阻塞队列

        阻塞队列是Java 5并发新特性中的内容,阻塞队列的接口是Java.util.concurrent.BlockingQueue,它有多个实现类:ArrayBlockingQueue、DelayQueue、LinkedBlockingQueue、PriorityBlockingQueue、SynchronousQueue等,用法大同小异,具体可查看JDK文档,这里简单举例看下ArrayBlockingQueue,它实现了一个有界队列,当队列满时,便会阻塞等待,直到有元素出队,后续的元素才可以被加入队列。

        看下面的例子:

    1. import java.util.concurrent.BlockingQueue;   
    2. import java.util.concurrent.ArrayBlockingQueue;   
    3.   
    4. public class BlockingQueueTest{   
    5.         public static void main(String[] args) throws InterruptedException {   
    6.                 BlockingQueue<String> bqueue = new ArrayBlockingQueue<String>(20);   
    7.                 for (int i = 0; i < 30; i++) {   
    8.                         //将指定元素添加到此队列中   
    9.                         bqueue.put("加入元素" + i);   
    10.                         System.out.println("向阻塞队列中添加了元素:" + i);   
    11.                 }   
    12.                 System.out.println("程序到此运行结束,即将退出----");   
    13.         }   
    14. }  
        输出结果如下:

        从执行结果中可以看出,由于队列中元素的数量限制在了20个,因此添加20个元素后,其他元素便在队列外阻塞等待,程序并没有终止。

        如果队列已满后,我们将队首元素移出,并可以继续向阻塞队列中添加元素,修改代码如下:

     

    1. import java.util.concurrent.BlockingQueue;   
    2. import java.util.concurrent.ArrayBlockingQueue;   
    3.   
    4. public class BlockingQueueTest{   
    5.         public static void main(String[] args) throws InterruptedException {   
    6.                 BlockingQueue<String> bqueue = new ArrayBlockingQueue<String>(20);   
    7.                 for (int i = 0; i < 30; i++) {   
    8.                         //将指定元素添加到此队列中   
    9.                         bqueue.put("" + i);   
    10.                         System.out.println("向阻塞队列中添加了元素:" + i);   
    11.                         if(i > 18){  
    12.                             //从队列中获取队头元素,并将其移出队列  
    13.                             System.out.println("从阻塞队列中移除元素:" + bqueue.take());  
    14.                         }  
    15.                 }   
    16.                 System.out.println("程序到此运行结束,即将退出----");   
    17.         }   
    18. }  
        执行结果如下:
        从结果中可以看出,当添加了第20个元素后,我们从队首移出一个元素,这样便可以继续向队列中添加元素,之后每添加一个元素,便从将队首元素移除,这样程序便可以执行结束。

         

     

    阻塞栈

       阻塞栈与阻塞队列相似,只是它是Java 6中加入的新特性,阻塞栈的接口java.util.concurrent.BlockingDeque也有很多实现类,使用方法也比较相似,具体查看JDK文档。

        下面同样给出一个简单的例子:

    1. import java.util.concurrent.BlockingDeque;   
    2. import java.util.concurrent.LinkedBlockingDeque;   
    3.   
    4. public class BlockingDequeTest {   
    5.     public static void main(String[] args) throws InterruptedException {   
    6.             BlockingDeque<String> bDeque = new LinkedBlockingDeque<String>(20);   
    7.             for (int i = 0; i < 30; i++) {   
    8.                 //将指定元素添加到此阻塞栈中  
    9.                 bDeque.putFirst("" + i);   
    10.                 System.out.println("向阻塞栈中添加了元素:" + i);   
    11.             }   
    12.             System.out.println("程序到此运行结束,即将退出----");   
    13.     }   
    14. }  
        执行结果如下:


        程序依然会阻塞等待,我们改为如下代码:

    1. import java.util.concurrent.BlockingDeque;   
    2. import java.util.concurrent.LinkedBlockingDeque;   
    3.   
    4. public class BlockingDequeTest {   
    5.     public static void main(String[] args) throws InterruptedException {   
    6.             BlockingDeque<String> bDeque = new LinkedBlockingDeque<String>(20);   
    7.             for (int i = 0; i < 30; i++) {   
    8.                 //将指定元素添加到此阻塞栈中  
    9.                 bDeque.putFirst("" + i);   
    10.                 System.out.println("向阻塞栈中添加了元素:" + i);   
    11.                 if(i > 18){  
    12.                     //从阻塞栈中取出栈顶元素,并将其移出  
    13.                     System.out.println("从阻塞栈中移出了元素:" + bDeque.pollFirst());  
    14.                 }  
    15.             }   
    16.             System.out.println("程序到此运行结束,即将退出----");   
    17.     }   
    18. }  
        执行结果如下:

        从结果中可以看出,当添加了第20个元素后,我们从将栈顶元素移处,这样便可以继续向栈中添加元素,之后每添加一个元素,便将栈顶元素移出,这样程序便可以执行结束。





  • 相关阅读:
    Python基础课:多继承
    Python基础课:定义一个函数,输入一个序列,判断序列是顺序还是逆序,顺序输出UP,逆序输出DOWN,否则输出None
    Python基础课:测试type 和 isinstance 那个的速度更快
    Python基础课:定义一个函数,可以对序列逆序的输出(对于列表和元组可以不用考虑嵌套的情况)
    WEBAPI获取数据
    jQuery中的.height()、.innerHeight()和.outerHeight()
    Javascript基类对象原型中有数组的情况
    必须关注的25位知名JavaScript开发者
    jQuery中的事件绑定函数.bind()、.live()、on()和.delegate()
    Javascript全局变量和delete
  • 原文地址:https://www.cnblogs.com/xuyatao/p/6919475.html
Copyright © 2020-2023  润新知