随笔-348  评论-598  文章-0  trackbacks-0

之前我们已经用常用方法写了一个消费者与生产者程序,不过看上去有点烦。在JDK 5里面,Java为我们提供了一个可以简化这方面开发的的接口

java.util.concurrent.BlockingQueue
使用BlockingQueue,我们的程序可以这样写
import java.util.concurrent.BlockingQueue;

public class ConsumerBlockingQueue extends Thread {

    
private final BlockingQueue<Integer> queue;
    
private final String name;
    
    
public ConsumerBlockingQueue(BlockingQueue<Integer> q, String name)
    
{
        queue
=q;
        
this.name=name;
    }

    
public void run() {
        
// TODO Auto-generated method stub
        try
        
{
            
while(true)
            
{
                consume(queue.take());
                
try
                
{
                    sleep(
800);// 将消费者的睡眠时间设置得比生产者小是为了演示当产品列表为空的情形
                }
catch(Exception e){
                    e.printStackTrace();
                }

            }

        }
catch(Exception e){
            e.printStackTrace();
        }

    }

    
    
private void consume(int i)
    
{
        System.out.println(name
+" consume "+i);
    }


}

这个是消费者类。
public class ProducerBlockingQueue extends Thread{
    
    
private final BlockingQueue<Integer> queue;
    
private final String name;
    
private static int i=0;
    
public ProducerBlockingQueue(BlockingQueue<Integer> q, String name)
    
{
        queue
=q;
        
this.name=name;
    }

    
    
public void run() {
        
// TODO Auto-generated method stub
        try
        
{
            
while(true)
            
{
                queue.add(produce());
                
try
                
{
                    sleep(
1000);
                }
catch(Exception e){
                    e.printStackTrace();
                }

            }

                
        }
catch(Exception e){
            e.printStackTrace();
        }


    }

    
    
private int produce()
    
{
        System.out.println(name
+" producing "+i);
        
return i++;
    }


}

这个是生产者类。
import java.util.*;
import java.util.Collection;
import java.util.Iterator;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;

public class Queue implements BlockingQueue {

    
private List list=new ArrayList();
    
public boolean add(Object o) {
        
// TODO Auto-generated method stub
        list.add(o);
        
return true;
    }


    
public Object take() throws InterruptedException {
        
// TODO Auto-generated method stub
        while(isEmpty()){}
        
return list.remove(0);
    }



    
public boolean isEmpty() {
        
// TODO Auto-generated method stub
        return list.isEmpty();
    }

// 当然这个类还有其他的方法需要实现,为了清楚起见,我把使用默认实现的方法都去掉了。

}

我们定义一个Queue来实现BlockingQueue。下面我们来测试下
import java.util.concurrent.BlockingQueue;


public class Test {

    
/**
     * 
@param args
     
*/

    
public static void main(String[] args) {
        
// TODO Auto-generated method stub
        BlockingQueue<Integer> q=new Queue();
        ProducerBlockingQueue p
=new ProducerBlockingQueue(q,"p");
        ProducerBlockingQueue p1
=new ProducerBlockingQueue(q,"p1");
        ConsumerBlockingQueue c
=new ConsumerBlockingQueue(q,"c");
        ConsumerBlockingQueue c1
=new ConsumerBlockingQueue(q,"c1");
        p.start();
        p1.start();
        c.start();
        c1.start();
    }


}

看到没有,就这么简单,以很少的逻辑代码实现了消费者与生产者功能,当然你还可以对他进行扩充,让他更加完善。


---------------------------------------------------------
专注移动开发

Android, Windows Mobile, iPhone, J2ME, BlackBerry, Symbian
posted on 2007-04-28 12:11 TiGERTiAN 阅读(2407) 评论(4)  编辑  收藏 所属分类: Java

评论:
# re: 使用BlockingQueue来简化消费者与生产者的问题 2007-04-28 14:18 | 王凌华
Java文档里面也有个类似的玩意,

-----------------------------------------------------------------
class Producer implements Runnable {
private final BlockingQueue queue;
Producer(BlockingQueue q) { queue = q; }
public void run() {
try {
while (true) { queue.put(produce()); }
} catch (InterruptedException ex) { ... handle ...}
}
Object produce() { ... }
}

class Consumer implements Runnable {
private final BlockingQueue queue;
Consumer(BlockingQueue q) { queue = q; }
public void run() {
try {
while (true) { consume(queue.take()); }
} catch (InterruptedException ex) { ... handle ...}
}
void consume(Object x) { ... }
}

class Setup {
void main() {
BlockingQueue q = new SomeQueueImplementation();
Producer p = new Producer(q);
Consumer c1 = new Consumer(q);
Consumer c2 = new Consumer(q);
new Thread(p).start();
new Thread(c1).start();
new Thread(c2).start();
}
}

你不是抄袭的吧。:)   回复  更多评论
  
# re: 使用BlockingQueue来简化消费者与生产者的问题 2007-04-28 14:28 | TiGERTiAN
哈哈。。抄袭抄袭。文档上面的不详细,写个能运行得出来。。当作学习。。  回复  更多评论
  
# re: 使用BlockingQueue来简化消费者与生产者的问题 2008-12-01 15:47 | qw
public Object take() throws InterruptedException {
// TODO Auto-generated method stub
while(isEmpty()){}
return list.remove(0);
}

while(isEmpty()){},这个代码你也敢写?  回复  更多评论
  
# re: 使用BlockingQueue来简化消费者与生产者的问题 2008-12-01 15:58 | TiGERTiAN
@qw
怎么了?是一个无限循环,主要是有一个生产线程在那里,我才这样写的,如果是实际开发当然要做相应处理,不能这样写了。  回复  更多评论
  

只有注册用户登录后才能发表评论。


网站导航: