移动端多线程编程高级篇-阻塞队列实现生产者消费者模式

1.生产者消费者模式非常经典的多线程编程

   不借助阻塞队列写法

   Vector v = new Vector();

       @Override
  public void run() {
   while(isRunning){
    synchronized (v) {

//如果Queue为空，不断阻塞中
     while(v.size() <= 0){
      try {
       v.wait();
      } catch (InterruptedException e) {
       e.printStackTrace();
      }
     }

  //如果队列有数据，获取移除队列的第一个元素，然后处理该元素
     if(v.size() > 0){
      Object obj = v.remove(0);

//处理队列中的元素

       handleReq(obj);
     }
    }
   }
  }

//向该队列中添加元素

  public void addReq(String str){
   synchronized (v) {
    v.add(str);
    v.notify();
   }
 }

2.借助阻塞队列LinkedBlockQueue的生产者消费者写法

   多个生产者一个消费者

   

   //5个生产者生产数据
for(int i = 0;i < 5;i++){
Thread thread = new Thread("tName->" + i){
public void run() {
super.run();
while(true){
int delay = (int) (Math.random() * 10);
try {
Thread.sleep(delay*1000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
int r = (int) (Math.random() * 10);
Producer p = new Producer();
p.data = r + "";
p.src = getName();
try {
System.out.println("tName-" + p.src + " 生产数据->" + r);
mQueue.put(p);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
};
};
thread.start();
}

//一个消费者
Thread threadConsumer = new Thread("consumer"){
@Override
public void run() {
super.run();
while(true){
try {
System.out.println(getName() + " waiting for take data...");
Producer p = mQueue.take();
System.out.println(getName() + " take data succ -> " + p.data + " from:" + p.src);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
threadConsumer.start();

   输出结果:

  consumer waiting for take data...
tName-tName->1 生产数据->6
tName-tName->3 生产数据->2
consumer take data succ -> 6 from:tName->1
consumer waiting for take data...
consumer take data succ -> 2 from:tName->3
consumer waiting for take data...
tName-tName->2 生产数据->6
consumer take data succ -> 6 from:tName->2
consumer waiting for take data...
tName-tName->3 生产数据->5
consumer take data succ -> 5 from:tName->3
consumer waiting for take data...
tName-tName->3 生产数据->0
tName-tName->1 生产数据->8
consumer take data succ -> 0 from:tName->3
consumer waiting for take data...
consumer take data succ -> 8 from:tName->1
consumer waiting for take data...
tName-tName->0 生产数据->0
consumer take data succ -> 0 from:tName->0
consumer waiting for take data...

    一个生产者多个消费者

   //一个生产者
Thread threadProducer = new Thread(){
@Override
public void run() {
super.run();
while(true){
for(int i = 0;i < 5;i++){
Producer p = new Producer();
int r = (int) (Math.random() * 100);
p.data = r+"";
System.out.println("生产者生产产品 " + r + " 放入到请求队列");
mQueue.add(p);
}

try {
Thread.sleep(1000*15);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
threadProducer.start();

//5个消费者消费数据
for(int i = 0;i < 5;i++){
Thread thread = new Thread("thread-"+i){
@Override
public void run() {
super.run();
while(true){
try {
System.out.println("tName->" + getName() + " waiting for take...");
Producer p = mQueue.take();
System.out.println("tName->" + getName() + " take data succ -> " + p.data);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
};
thread.start();
}

输出结果:

tName->thread-1 waiting for take...
生产者生产产品 55 放入到请求队列
tName->thread-1 take data succ -> 55
tName->thread-1 waiting for take...
生产者生产产品 83 放入到请求队列
tName->thread-1 take data succ -> 83
tName->thread-1 waiting for take...
生产者生产产品 39 放入到请求队列
tName->thread-1 take data succ -> 39
tName->thread-1 waiting for take...
生产者生产产品 61 放入到请求队列
生产者生产产品 56 放入到请求队列
tName->thread-4 waiting for take...
tName->thread-4 take data succ -> 56
tName->thread-4 waiting for take...
tName->thread-0 waiting for take...
tName->thread-3 waiting for take...
tName->thread-2 waiting for take...
tName->thread-1 take data succ -> 61
tName->thread-1 waiting for take...