Java队列和定时器Timer

   一： Queue详解

   Queue： 基本上，一个队列就是一个先入先出（FIFO）的数据结构

   Queue接口与List、Set同一级别，都是继承了Collection接口。LinkedList实现了Deque接 口。

  

  1)、没有实现的阻塞接口的LinkedList： 实现了java.util.Queue接口和java.util.AbstractQueue接口
　　内置的不阻塞队列： PriorityQueue 和 ConcurrentLinkedQueue
　　PriorityQueue 和 ConcurrentLinkedQueue 类在 Collection Framework 中加入两个具体集合实现。 
　　PriorityQueue 类实质上维护了一个有序列表。加入到 Queue 中的元素根据它们的天然排序（通过其 java.util.Comparable 实现）或者根据传递给构造函数的 java.util.Comparator 实现来定位。
　　ConcurrentLinkedQueue 是基于链接节点的、线程安全的队列。并发访问不需要同步。因为它在队列的尾部添加元素并从头部删除它们，所以只要不需要知道队列的大 小，ConcurrentLinkedQueue 对公共集合的共享访问就可以工作得很好。收集关于队列大小的信息会很慢，需要遍历队列。

  2)、实现阻塞接口的：
　　java.util.concurrent 中加入了 BlockingQueue 接口和五个阻塞队列类。它实质上就是一种带有一点扭曲的 FIFO 数据结构。不是立即从队列中添加或者删除元素，线程执行操作阻塞，直到有空间或者元素可用。
五个队列所提供的各有不同：
　　* ArrayBlockingQueue ：一个由数组支持的有界队列。
　　* LinkedBlockingQueue ：一个由链接节点支持的可选有界队列。
　　* PriorityBlockingQueue ：一个由优先级堆支持的无界优先级队列。
　　* DelayQueue ：一个由优先级堆支持的、基于时间的调度队列。
　　* SynchronousQueue ：一个利用 BlockingQueue 接口的简单聚集（rendezvous）机制。

                    

　　下表显示了jdk1.5中的阻塞队列的操作：

　　　　add        增加一个元索                     如果队列已满，则抛出一个IIIegaISlabEepeplian异常
　　　　remove   移除并返回队列头部的元素    如果队列为空，则抛出一个NoSuchElementException异常
　　　　element  返回队列头部的元素             如果队列为空，则抛出一个NoSuchElementException异常
　　　　offer       添加一个元素并返回true       如果队列已满，则返回false
　　　　poll         移除并返问队列头部的元素    如果队列为空，则返回null
　　　　peek       返回队列头部的元素             如果队列为空，则返回null
　　　　put         添加一个元素                      如果队列满，则阻塞
　　　　take        移除并返回队列头部的元素     如果队列为空，则阻塞

    3)、示例

 1 package com.svse.queue;
 3 import java.util.LinkedList;
 4 import java.util.Queue;
 7 import java.util.Timer;
 8 import java.util.TimerTask;
10 import com.svse.entity.Users;
11 
12 class TestQueue {
13 
14     static Queue queueUsers=new LinkedList();
15     static{
16         Users user1=new Users("201","张三","男","27","歌手");
17         Users user2=new Users("202","李思","女","26","演员");
18         queueUsers.add(user1);
19         queueUsers.add(user2);
20     }
21     
22     public void test1(){
23         
24         Queue queue = new LinkedList();
25         queue.offer("Hello");
26         queue.offer("World!");
27         queue.offer("你好！");
28         
29         System.out.println(queue.size());
30         
31         
32         while (queue.size() > 0) {
33             String element = queue.poll();
34             System.out.println(element);
35         }
36        System.out.println();
37        System.out.println(queue.size());
38     }
39     
40     //生产者
41     public void producerQueue(){
42         
43         System.out.println(queueUsers.size());
44     }
45     
46     //消费者
47     public void consumerQueue(){
48         Users u=null;
49          while((u=queueUsers.poll())!=null){
50                System.out.println(u+" ");
51             }
52        System.out.println();
53        System.out.println(queueUsers.size());
54     }
55    
69     
70     public static void main(String[] args) {
71         TestQueue tq=new TestQueue();
72         //tq.producerQueue();
73         //tq.consumerQueue();
74         
75         timerTest();
76         
77         
78         
79     }
80 
81 }

二： 不怕难之BlockingQueue及其实现

  1)、 前言

       BlockingQueue即阻塞队列，它是基于ReentrantLock，依据它的基本原理，我们可以实现Web中的长连接聊天功能，当然其最常用的还是用于实现生产者与消费者模式，大致如下图所示：

                                  

 

 

        在Java中，BlockingQueue是一个接口，它的实现类有ArrayBlockingQueue、DelayQueue、 LinkedBlockingDeque、LinkedBlockingQueue、PriorityBlockingQueue、SynchronousQueue等，它们的区别主要体现在存储结构上或对元素操作上的不同，但是对于take与put操作的原理，却是类似的。

  2)、阻塞与非阻塞

  入队

offer(E e)：如果队列没满，立即返回true； 如果队列满了，立即返回false-->不阻塞

put(E e)：如果队列满了，一直阻塞，直到队列不满了或者线程被中断-->阻塞

offer(E e, long timeout, TimeUnit unit)：在队尾插入一个元素,，如果队列已满，则进入等待，直到出现以下三种情况：-->阻塞

被唤醒

等待时间超时

当前线程被中断

  出队

poll()：如果没有元素，直接返回null；如果有元素，出队

take()：如果队列空了，一直阻塞，直到队列不为空或者线程被中断-->阻塞

poll(long timeout, TimeUnit unit)：如果队列不空，出队；如果队列已空且已经超时，返回null；如果队列已空且时间未超时，则进入等待，直到出现以下三种情况：

被唤醒

等待时间超时

当前线程被中断

  3)、示例   

 1 package com.yao;
 2 import java.util.concurrent.ArrayBlockingQueue;
 3 import java.util.concurrent.BlockingQueue;
 4 import java.util.concurrent.ExecutorService;
 5 import java.util.concurrent.Executors;
 6 public class BlockingQueueTest {
 7  /**
 8  定义装苹果的篮子
 9   */
10  public static class Basket{
11   // 篮子，能够容纳3个苹果
12   BlockingQueue basket = new ArrayBlockingQueue(3);
13 
14   // 生产苹果，放入篮子
15   public void produce() throws InterruptedException{
16    // put方法放入一个苹果，若basket满了，等到basket有位置
17    basket.put("An apple");
18   }
19   // 消费苹果，从篮子中取走
20   public String consume() throws InterruptedException{
21    // get方法取出一个苹果，若basket为空，等到basket有苹果为止
22    String apple = basket.take();
23    return apple;
24   }
25 
26   public int getAppleNumber(){
27    return basket.size();
28   }
29 
30  }
31  //　测试方法
32  public static void testBasket() {
33   // 建立一个装苹果的篮子
34   final Basket basket = new Basket();
35   // 定义苹果生产者
36   class Producer implements Runnable {
37    public void run() {
38     try {
39      while (true) {
40       // 生产苹果
41       System.out.println("生产者准备生产苹果：" 
42         + System.currentTimeMillis());
43       basket.produce();
44       System.out.println("生产者生产苹果完毕：" 
45         + System.currentTimeMillis());
46       System.out.println("生产完后有苹果："+basket.getAppleNumber()+"个");
47       // 休眠300ms
48       Thread.sleep(300);
49      }
50     } catch (InterruptedException ex) {
51     }
52    }
53   }
54   // 定义苹果消费者
55   class Consumer implements Runnable {
56    public void run() {
57     try {
58      while (true) {
59       // 消费苹果
60       System.out.println("消费者准备消费苹果：" 
61         + System.currentTimeMillis());
62       basket.consume();
63       System.out.println("消费者消费苹果完毕：" 
64         + System.currentTimeMillis());
65       System.out.println("消费完后有苹果："+basket.getAppleNumber()+"个");
66       // 休眠1000ms
67       Thread.sleep(1000);
68      }
69     } catch (InterruptedException ex) {
70     }
71    }
72   }
73 
74   ExecutorService service = Executors.newCachedThreadPool();
75   Producer producer = new Producer();
76   Consumer consumer = new Consumer();
77   service.submit(producer);
78   service.submit(consumer);
79   // 程序运行10s后，所有任务停止
80   try {
81    Thread.sleep(10000);
82   } catch (InterruptedException e) {
83   }
84   service.shutdownNow();
85  }
86
87  public static void main(String[] args) {
88   BlockingQueueTest.testBasket();
89  }
90 }

三： 定时器之Timer

 1 package com.svse.queue;
 2 import java.util.Timer;
 3 import java.util.TimerTask;
 4 
 5 public class TestTimer {
 6 
 7 
 8     static int i=0;
 9     public static void timerTest(){
10         //创建一个定时器
11         Timer timer = new Timer();
12         //schedule方法是执行时间定时任务的方法
13         timer.schedule(new TimerTask() {
14             @Override
15             public void run() {
16                 i++;
17                 System.out.println("timerTest: "+i);
18             }
19         }, 1000, 60000); //第一个参数时间 从多少毫秒之后开始执行   第二个时间参数  间隔多少毫秒之后再执行 1分钟一次
20     }
21 
22     
23     public static void main(String[] args) {
24 
25         timerTest();
26         
27     }
28 
29 }

 

转载于:https://www.cnblogs.com/zhaosq/p/11233281.html