LinkedBlockingDeque工作密取

转载 2015年07月08日 17:52:22
  1. package com.java;  
  2.   
  3. import java.util.Random;  
  4. import java.util.concurrent.LinkedBlockingDeque;  
  5.   
  6. public class SecretWorkFetch {  
  7.     private static class Work implements Runnable{  
  8.         private static Object object=new Object();  
  9.         private static int count=0;  
  10.         public final int id;  
  11.         private long putThread;   
  12.         public Work(){  
  13.             synchronized(object){  
  14.                 id=count++;  
  15.             }  
  16.         }  
  17.         @Override  
  18.         public void run() {  
  19.             if(Thread.currentThread().getId()!=putThread){  
  20.                 System.out.println("===================================================");  
  21.             }  
  22.             System.out.println(Thread.currentThread().getId()+":"+putThread+"// finish job "+id);  
  23.               
  24.         }  
  25.         public long getPutThread() {  
  26.             return putThread;  
  27.         }  
  28.         public void setPutThread(long putThread) {  
  29.             this.putThread = putThread;  
  30.         }  
  31.           
  32.           
  33.           
  34.     }  
  35.     public static Work generateWork(){  
  36.         return new Work();  
  37.     }  
  38.     private static class ConsumerAndProducer implements Runnable{  
  39.         private Random random=new Random();  
  40.         private final LinkedBlockingDeque<Work> deque;  
  41.         private final LinkedBlockingDeque<Work> otherWork;  
  42.         public ConsumerAndProducer(LinkedBlockingDeque<Work> deque,LinkedBlockingDeque<Work> otherWork){  
  43.             this.deque=deque;  
  44.             this.otherWork=otherWork;  
  45.         }  
  46.         @Override  
  47.         public void run() {  
  48.             while(!Thread.interrupted()){  
  49.                 try {  
  50.                     Thread.sleep(200);  
  51.                     if(random.nextBoolean()){  
  52.                         int count=random.nextInt(5);  
  53.                         for(int i=0;i<count;i++){  
  54.                             Work w=generateWork();  
  55.                             w.setPutThread(Thread.currentThread().getId());  
  56.                             deque.putLast(w);  
  57.                         }  
  58.                     }  
  59.                     if(deque.isEmpty()){  
  60.                         if(!otherWork.isEmpty()){  
  61.                             otherWork.takeLast().run();;  
  62.                         }  
  63.                           
  64.                     }else{  
  65.                         deque.takeFirst().run();  
  66.                     }  
  67.                 } catch (InterruptedException e) {  
  68.                       
  69.                 }  
  70.             }  
  71.               
  72.               
  73.               
  74.         }  
  75.           
  76.           
  77.     }  
  78.       
  79.       
  80.     public static void main(String[] args) {  
  81.         LinkedBlockingDeque<Work> deque=new LinkedBlockingDeque<Work>();  
  82.         LinkedBlockingDeque<Work> other=new LinkedBlockingDeque<Work>();  
  83.         new Thread(new ConsumerAndProducer(deque,other)).start();  
  84.         new Thread(new ConsumerAndProducer(deque,other)).start();  
  85.           
  86.         new Thread(new ConsumerAndProducer(other,deque)).start();  
  87.         new Thread(new ConsumerAndProducer(other,deque)).start();  
  88.     }  
  89.   

相关文章推荐

LinkedBlockingDeque工作密取

package com.java; import java.util.Random; import java.util.concurrent.LinkedBlockingDeque; public...

双端队列和工作密取

Java6增加了两种容器类型,Deque和BlockingDeque,它们分别对Queue和BlockingQueue进行了扩展。 Deque是一个双端队列,实现了在队列头和队列尾的高效插入和移除。...
  • zjt1388
  • zjt1388
  • 2014年09月25日 00:02
  • 1585

java并发编程(二十五)----(JUC集合)LinkedBlockingDeque和ConcurrentLinkedDeque介绍

Queue除了前面介绍的实现外,还有一种双向的Queue实现Deque。这种队列允许在队列头和尾部进行入队出队操作,因此在功能上比Queue显然要更复杂。LinkedBlockingDeque我们来看...

LinkedBlockingDeque实现生产者消费者

生产者消费者原理解释: 生产者消费者的模型是指的是在多个线程间同时操作同一快的内存;一部分的线程向内存中添加数据(生产者) 一部分线程将内存中的数据取出并再这一块的内存中取消该数据(消费者);当内存...

JUC源码分析21-队列-LinkedBlockingDeque

LinkedBlockingDeque基于双向链表实现的阻塞队列,根据构造传入的容量大小决定有界还是无界,默认不传的话,大小Integer.Max。 实现BlockingDequeue接口,这个接口...

Java多线程(六)之Deque与LinkedBlockingDeque深入分析

一、双向队列Deque Queue除了前面介绍的实现外,还有一种双向的Queue实现Deque。这种队列允许在队列头和尾部进行入队出队操作,因此在功能上比Queue显然要更复杂。下图...

JUC集合-09之 LinkedBlockingDeque

0. 本文目录本章介绍JUC包中的LinkedBlockingDeque。 内容包括: [TOC]1. LinkedBlockingDeque介绍LinkedBlockingDeque是双向链表实...

java多线程-新特征-阻塞栈LinkedBlockingDeque

ava多线程-新特征-阻塞栈LinkedBlockingDeque 对于阻塞栈,与阻塞队列相似。不同点在于栈是“后入先出”的结构,每次操作的是栈顶,而队列是“先进先出”的结构,每次操作的是队列头...

双向队列---Deque与LinkedBlockingDeque深入分析

 一、双向队列Deque Queue除了前面介绍的实现外,还有一种双向的Queue实现Deque。这种队列允许在队列头和尾部进行入队出队操作,因此在功能上比Queue显然要更复...

同步容器、并发容器、阻塞队列、双端队列与工作密取

在多线程的开发中经常会碰到数据的并发修改,并发存取,因此正确的使用不同的容器很关键,直接影响到数据的正确性。下面主要记录下三种重要的队列,以及一种非常使用的双端队列。 1、同步容器        主要...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:LinkedBlockingDeque工作密取
举报原因:
原因补充:

(最多只允许输入30个字)