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)、示例

 package com.svse.queue;
 import java.util.LinkedList;
 import java.util.Queue;
 import java.util.Timer;
 import java.util.TimerTask;
 import com.svse.entity.Users;

 class TestQueue {

     static Queue<Users> queueUsers=new LinkedList<Users>();
     static{
         Users user1=new Users("201","张三","男","27","歌手");
         Users user2=new Users("202","李思","女","26","演员");
         queueUsers.add(user1);
         queueUsers.add(user2);
     }

     public void test1(){

         Queue<String> queue = new LinkedList<String>();
         queue.offer("Hello");
         queue.offer("World!");
         queue.offer("你好！");

         System.out.println(queue.size());

         while (queue.size() > 0) {
             String element = queue.poll();
             System.out.println(element);
         }
        System.out.println();
        System.out.println(queue.size());
     }

     //生产者
     public void producerQueue(){

         System.out.println(queueUsers.size());
     }

     //消费者
     public void consumerQueue(){
         Users u=null;
          while((u=queueUsers.poll())!=null){
                System.out.println(u+" ");
             }
        System.out.println();
        System.out.println(queueUsers.size());
     }

     public static void main(String[] args) {
         TestQueue tq=new TestQueue();
         //tq.producerQueue();
         //tq.consumerQueue();

         timerTest();

     }

 }

二： 不怕难之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)、示例

 package com.yao;
 import java.util.concurrent.ArrayBlockingQueue;
 import java.util.concurrent.BlockingQueue;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 public class BlockingQueueTest {
  /**
  定义装苹果的篮子
   */
  public static class Basket{
   // 篮子，能够容纳3个苹果
   BlockingQueue<String> basket = new ArrayBlockingQueue<String>(3);

   // 生产苹果，放入篮子
   public void produce() throws InterruptedException{
    // put方法放入一个苹果，若basket满了，等到basket有位置
    basket.put("An apple");
   }
   // 消费苹果，从篮子中取走
   public String consume() throws InterruptedException{
    // get方法取出一个苹果，若basket为空，等到basket有苹果为止
    String apple = basket.take();
    return apple;
   }

   public int getAppleNumber(){
    return basket.size();
   }

  }
  //　测试方法
  public static void testBasket() {
   // 建立一个装苹果的篮子
   final Basket basket = new Basket();
   // 定义苹果生产者
   class Producer implements Runnable {
    public void run() {
     try {
      while (true) {
       // 生产苹果
       System.out.println("生产者准备生产苹果："
         + System.currentTimeMillis());
       basket.produce();
       System.out.println("生产者生产苹果完毕："
         + System.currentTimeMillis());
       System.out.println("生产完后有苹果："+basket.getAppleNumber()+"个");
       // 休眠300ms
       Thread.sleep(300);
      }
     } catch (InterruptedException ex) {
     }
    }
   }
   // 定义苹果消费者
   class Consumer implements Runnable {
    public void run() {
     try {
      while (true) {
       // 消费苹果
       System.out.println("消费者准备消费苹果："
         + System.currentTimeMillis());
       basket.consume();
       System.out.println("消费者消费苹果完毕："
         + System.currentTimeMillis());
       System.out.println("消费完后有苹果："+basket.getAppleNumber()+"个");
       // 休眠1000ms
       Thread.sleep(1000);
      }
     } catch (InterruptedException ex) {
     }
    }
   }

   ExecutorService service = Executors.newCachedThreadPool();
   Producer producer = new Producer();
   Consumer consumer = new Consumer();
   service.submit(producer);
   service.submit(consumer);
   // 程序运行10s后，所有任务停止
   try {
    Thread.sleep(10000);
   } catch (InterruptedException e) {
   }
   service.shutdownNow();
  }
86
  public static void main(String[] args) {
   BlockingQueueTest.testBasket();
  }
 }

三： 定时器之Timer

 package com.svse.queue;
 import java.util.Timer;
 import java.util.TimerTask;

 public class TestTimer {

     static int i=0;
     public static void timerTest(){
         //创建一个定时器
         Timer timer = new Timer();
         //schedule方法是执行时间定时任务的方法
         timer.schedule(new TimerTask() {
             @Override
             public void run() {
                 i++;
                 System.out.println("timerTest: "+i);
             }
         }, 1000, 60000); //第一个参数时间 从多少毫秒之后开始执行   第二个时间参数  间隔多少毫秒之后再执行 1分钟一次
     }

     public static void main(String[] args) {

         timerTest();

     }

 }