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

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...