关闭

JAVA多线程(五)用lock、synchronized、阻塞队列三种方法实现生产者消费者模式

标签: 多线程生产者消费者
2288人阅读 评论(1) 收藏 举报
分类:

这篇博客算是上一篇JAVA多线程(三)生产者消费者模式及实现方法的补充。用三种方法(lock、synchronized、阻塞队列)实现生产者消费者模式。具体内容是:生产者产生随机数(为了方便阅读结果,我把随机数限定在10以内的整数),消费者读取并打印。

1 阻塞队列实现生产者消费者模式

阻塞队列是最简单的实现方法

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.Random;

public class BlockingQueuePattern {

    public static void main(String args[]){

     //阻塞队列
     BlockingQueue sharedQueue = new LinkedBlockingQueue();

     //创建生产者线程和消费者线程
     Thread prodThread = new Thread(new Producer(sharedQueue));
     Thread consThread = new Thread(new Consumer(sharedQueue));

     //启动生产者线程和消费者线程
     prodThread.start();
     consThread.start();
    }
}

//生产者类
class Producer implements Runnable {

    private final BlockingQueue sharedQueue;

    public Producer(BlockingQueue sharedQueue) {
        this.sharedQueue = sharedQueue;
    }

    @Override
    public void run() {
        for(int i=0; i<10; i++){
            try {
                //产生10以内的随机整数放入阻塞队列
                Random random = new Random();
                int ProdRandom=random.nextInt(10);
                System.out.println("Produced: " + ProdRandom);
                sharedQueue.put(ProdRandom);
            } catch (InterruptedException ex) {
                Logger.getLogger(Producer.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
}

//消费者类
class Consumer implements Runnable{

    private final BlockingQueue sharedQueue;

    public Consumer (BlockingQueue sharedQueue) {
        this.sharedQueue = sharedQueue;
    }

    @Override
    public void run() {
        while(true){
            try {
                System.out.println("Consumed: "+ sharedQueue.take());
            } catch (InterruptedException ex) {
                Logger.getLogger(Consumer.class.getName()).log(Level.SEVERE, null, ex);
            }
        }
    }
} 
Output:
Produced: 4
Produced: 7
Produced: 8
Consumed: 4
Consumed: 7
Produced: 6
Consumed: 8
Consumed: 6
Produced: 1
Produced: 7
Consumed: 1
Consumed: 7
Produced: 3
Produced: 5
Consumed: 3
Consumed: 5
Produced: 9
Produced: 7
Consumed: 9
Consumed: 7

2 lock实现生产者消费者模式

既然不用JAVA提供给我们的现成的阻塞队列,我们不如自己创建一个队列,代码如下:

import java.util.LinkedList;
import java.util.Random;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class OptimisticLockPattern {
    public static void main(String[] args){     
         SelfQueue selfqueue = new SelfQueue();

         //创建生产者线程和消费者线程
         Thread prodThread = new Thread(new Producer(selfqueue));
         Thread consThread = new Thread(new Consumer(selfqueue));

         //启动生产者线程和消费者线程
         prodThread.start();
         consThread.start();
    }
}


class SelfQueue{
    int max = 5;
    LinkedList<Integer> ProdLine = new LinkedList<Integer>();
    Lock lock = new ReentrantLock(); 
    Condition full = lock.newCondition();  
    Condition empty = lock.newCondition();

    public void produce(int ProdRandom){       
        try {
            lock.lock();
            while(max == ProdLine.size()){
                System.out.println("存储量达到上限,请等待");
                full.await();
            }
            ProdLine.add(ProdRandom);
            empty.signal();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally{
            lock.unlock();
        }
    } 

    public int consume(){  
        int m = 0;
        try {
            lock.lock();
            while(ProdLine.size() == 0){
                System.out.println("队列是空的,请稍候");
                empty.await();
            }
            m = ProdLine.removeFirst();
            full.signal(); 
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally{
            lock.unlock();
            return m;
        }
    }
}

//生产者
class Producer implements Runnable{
    private final SelfQueue selfqueue;

    public Producer(SelfQueue selfqueue) {
          this.selfqueue = selfqueue;
    }

    public void run() {
      for (int i = 0; i < 10; i++) {
            Random random = new Random();
            int ProdRandom=random.nextInt(10);
            System.out.println("Produced: " + ProdRandom);
            selfqueue.produce(ProdRandom);          
      }
  }
}

//消费者
class Consumer implements Runnable{
    private final SelfQueue selfqueue;

    public Consumer(SelfQueue selfqueue) {
          this.selfqueue = selfqueue;
    }

    public void run() {
      while(true) {
              System.out.println("Consumed: "+ selfqueue.consume());
      }
  }
}
Output:
Produced: 1
Produced: 9
Consumed: 1
Consumed: 9
队列是空的,请稍候
Produced: 9
Produced: 1
Consumed: 9
Produced: 8
Consumed: 1
Consumed: 8
队列是空的,请稍候
Produced: 6
Produced: 8
Consumed: 6
Produced: 4
Consumed: 8
Produced: 4
Consumed: 4
Produced: 0
Consumed: 4
Consumed: 0
队列是空的,请稍候

3 synchronized实现生产者消费者模式

synchronized不需要自己手动解锁,这里用到了前面提过的wait()&notify()方法。

import java.util.Random;

public class PessimisticLockPattern {
    public static void main(String[] args){     
         SelfQueue selfqueue = new SelfQueue();

         //创建生产者线程和消费者线程
         Thread prodThread = new Thread(new Producer(selfqueue));
         Thread consThread = new Thread(new Consumer(selfqueue));

         //启动生产者线程和消费者线程
         prodThread.start();
         consThread.start();
    }
}


class SelfQueue{
    int index = 0; 
    int[] ProdLine = new int[6];

    public synchronized void produce(int ProdRandom){
        while(index == ProdLine.length){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notify();
        ProdLine[index] = ProdRandom;
        index++;
    }

    public synchronized int consume(){
        while(index == 0){
            try {
                this.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        this.notify();
        index--;
        return ProdLine[index];
    }
}

//生产者
class Producer implements Runnable{
    private final SelfQueue selfqueue;

    public Producer(SelfQueue selfqueue) {
        this.selfqueue = selfqueue;
  }

  public void run() {
    for (int i = 0; i < 10; i++) {
            Random random = new Random();
            int ProdRandom = random.nextInt(10);
        System.out.println("Produced: " + ProdRandom);
            selfqueue.produce(ProdRandom);          
    }
}
}

//消费者
class Consumer implements Runnable{
    private final SelfQueue selfqueue;

  public Consumer(SelfQueue selfqueue) {
        this.selfqueue = selfqueue;
  }

  public void run() {
    while(true) {
          System.out.println("Consumed: "+ selfqueue.consume());
    }
}
}
Output:
Produced: 3
Produced: 3
Consumed: 3
Produced: 8
Produced: 3
Consumed: 3
Produced: 2
Produced: 6
Consumed: 3
Produced: 7
Produced: 8
Produced: 1
Produced: 9
Consumed: 6
Consumed: 9
Consumed: 1
Consumed: 8
Consumed: 7
Consumed: 2
Consumed: 8
1
0
查看评论

Java并发编程:阻塞队列及实现生产者-消费者模式

1 什么是阻塞队列  JDK 1.5的java.util.concurrent包提供了多种阻塞队列。阻塞队列相对于PriorityQueue、LinkedList等非阻塞队列的特点是提供了,队列阻塞的操作,优化了队列为空向队列取数据或者队列满向队列加数据时的阻塞操作。以生产者-消费者模式为例,当队列...
  • sk199048
  • sk199048
  • 2016-01-24 14:38
  • 563

java使用阻塞队列实现生产者消费者模式

Java 5之前实现同步存取时,可以使用普通的一个集合,然后在使用线程的协作和线程同步可以实现生产者,消费者模式,主要的技术就是用好,wait ,notify,notifyAll,sychronized这些关键字。而在java 5之后,可以使用组阻塞队列来实现,此方式大大简少了代码量,使得多线程...
  • Nickjun123
  • Nickjun123
  • 2015-08-09 17:02
  • 2884

JAVA多线程(三)生产者消费者模式及实现方法

介绍了生产者消费者模式以及实现方法(wait&notify,阻塞队列
  • antony9118
  • antony9118
  • 2016-05-23 15:15
  • 2688

高并发:阻塞队列 实现生产者-消费者模式

首先介绍一下非阻塞队列,比如PriorityQueue、LinkedList。在使用非阻塞队列时遇到的问题:不会对当前线程产生阻塞,在面对类似消费者-生产者的模型时,必须额外地实现同步策略以及线程间唤醒策略,这个实现起来非常麻烦。 所以,阻塞队列恰恰不一样,阻塞队列会对当前线程产生阻塞,比如一个线...
  • g893465244
  • g893465244
  • 2016-09-12 11:32
  • 2594

java高并发锁的3种实现

提到锁,大家可能都会想到synchronized关键字,使用它的确可以解决一切并发问题,但是对于系统吞吐要求更高的,在这里提供了几个小技巧,帮助大家减小锁粒度,提高系统并发能力。 初级技巧 - 乐观锁 乐观锁适合这样的场景:读不会冲突,写会冲突。同时读的频率远大于写。 ...
  • hl_java
  • hl_java
  • 2017-04-12 22:36
  • 6366

Java多线程之生产者消费者问题<一>:使用synchronized 关键字解决生产者消费者问题

今天看了一片博文,讲Java多线程之线程的协作,其中作者用程序实例说明了生产者和消费者问题,但我及其他读者发现程序多跑几次还是会出现死锁,百度搜了下大都数的例子也都存在bug,经过仔细研究发现其中的问题,并解决了,感觉有意义贴出来分享下。
  • feichenwangyalin
  • feichenwangyalin
  • 2014-10-16 22:22
  • 1908

Java 多线程加锁的方式总结及对比

参考博文:http://www.cnblogs.com/handsomeye/p/5999362.html 一.Java多线程可以通过: 1. synchronized关键字 2. Java.util.concurrent包中的lock接口和ReentrantLock实现类 这两种方...
  • u010842515
  • u010842515
  • 2017-03-28 14:27
  • 4637

【Java多线程 锁优化】锁的三种状态切换

转自http://ifeve.com/java-synchronized/ 引言在多线程并发编程中Synchronized一直是元老级角色,很多人都会称呼它为重量级锁,但是随着Java SE1.6对Synchronized进行了各种优化之后,有些情况下它并不那么重了,本文详细介绍了Java SE1....
  • sinat_33087001
  • sinat_33087001
  • 2017-09-05 11:46
  • 296

JAVA synchronized 线程经典 生产者消费者 两个完全不同的实现的方式

package sell_ticket; public class ThreadTicket { public static void main(String[] args) { MyThread m = new MyThread(); ...
  • hjm4702192
  • hjm4702192
  • 2012-08-23 16:36
  • 1027

Java并发之生产者-消费者几种实现

关于生产者-消费者Java实现,这里看到了一篇写的不错的文章,欢迎补充! 引用地址:http://blog.csdn.net/monkey_d_meng/article/details/6251879 生产者消费者问题是研究多线程程序时绕不开的经典问题之一,它描述是有一块缓冲区作为仓...
  • zhuqiuhui
  • zhuqiuhui
  • 2016-08-01 10:59
  • 1156
    个人资料
    • 访问:203981次
    • 积分:2479
    • 等级:
    • 排名:第17611名
    • 原创:60篇
    • 转载:52篇
    • 译文:3篇
    • 评论:49条
    博客专栏
    文章分类
    最新评论