由生产者/消费者问题看JAVA多线程

举报
ShaderJoy 发表于 2021/12/30 01:21:21 2021/12/30
【摘要】 转自:http://blog.csdn.net/coutcin/article/details/1213834 生产者消费者问题是研究多线程程序时绕不开的问题,它的描述是有一块生产者和消费者共享的有界缓冲区,生产者往缓冲区放入产品,消费者从缓冲区取走产品,这个过程可以无休止的执行,不能因缓冲区满生产者放不进产品而终止,...
转自:http://blog.csdn.net/coutcin/article/details/1213834
生产者消费者问题是研究多线程程序时绕不开的问题,它的描述是有一块生产者和消费者共享的有界缓冲区,生产者往缓冲区放入产品,消费者从缓冲区取走产品,这个过程可以无休止的执行,不能因缓冲区满生产者放不进产品而终止,也不能因缓冲区空消费者无产品可取而终止。
解决生产者消费者问题的方法有两种,
一种是采用某种机制保持生产者和消费者之间的同步 一种是在生产者和消费者之间建立一个管道 。前一种有较高的效率并且可控制性较好,比较常用,后一种由于管道缓冲区不易控制及被传输数据对象不易封装等原因,比较少用。
同步问题的核心在于,CPU是按时间片轮询的方式执行程序,我们无法知道某一个线程是否被执行、是否被抢占、是否结束等,因此生产者完全可能当缓冲区已满的时候还在放入产品,消费者也完全可能当缓冲区为空时还在取出产品。
现在 同步问题的解决方法 一般是采用信号或者加锁机制,即生产者线程当缓冲区已满时放弃自己的执行权,进入等待状态,并通知消费者线程执行。消费者线程当缓冲区已空时放弃自己的执行权,进入等待状态,并通知生产者线程执行。这样一来就保持了线程的同步,并避免了线程间互相等待而进入死锁状态。
JAVA语言提供了独立于平台的线程机制,保持了”write once, run anywhere”的特色。同时也提供了对同步机制的良好支持。
在JAVA中,一共有四种方法支持同步, 其中三个是同步方法,一个是管道方法
1. 方法wait()/notify()
2. 方法await()/signal()
3. 阻塞队列方法BlockingQueue
4. 管道方法PipedInputStream/PipedOutputStream
下面我们看各个方法的实现:
1. 方法wait()/notify()
wait()和notify()是根类Object的两个方法,也就意味着所有的JAVA类都会具有这个两个方法,为什么会被这样设计呢?我们可以认为所有的对象默认都具有一个锁,虽然我们看不到,也没有办法直接操作,但它是存在的。
wait()方法表示:当缓冲区已满或空时,生产者或消费者线程停止自己的执行,放弃锁,使自己处于等待状态,让另一个线程开始执行;
notify()方法表示:当生产者或消费者对缓冲区放入或取出一个产品时,向另一个线程发出可执行通知,同时放弃锁,使自己处于等待状态。
下面是一个例子代码:

   
  1. import java.util.LinkedList;
  2. public class Sycn1{
  3. private LinkedList<Object> myList =new LinkedList<Object>();
  4. private int MAX = 10;
  5. public Sycn1(){
  6. }
  7. public void start(){
  8. new Producer().start();
  9. new Consumer().start();
  10. }
  11. public static void main(String[] args) throws Exception{
  12. Sycn1 s1 = new Sycn1();
  13. s1.start();
  14. }
  15. class Producer extends Thread{
  16. public void run(){
  17. while(true){
  18. synchronized(myList){
  19. try{
  20. while(myList.size() == MAX){
  21. System.out.println("warning: it's full!");
  22. myList.wait();
  23. }
  24. Object o = new Object();
  25. if(myList.add(o)){
  26. System.out.println("Producer: " + o);
  27. myList.notify();
  28. }
  29. }catch(InterruptedException ie){
  30. System.out.println("producer is interrupted!");
  31. }
  32. }
  33. }
  34. }
  35. }
  36. class Consumer extends Thread{
  37. public void run(){
  38. while(true){
  39. synchronized(myList){
  40. try{
  41. while(myList.size() == 0){
  42. System.out.println("warning: it's empty!");
  43. myList.wait();
  44. }
  45. Object o = myList.removeLast();
  46. System.out.println("Consumer: " + o);
  47. myList.notify();
  48. }catch(InterruptedException ie){
  49. System.out.println("consumer is interrupted!");
  50. }
  51. }
  52. }
  53. }
  54. }
  55. }
2.        方法await()/signal()
在JDK5.0以后,JAVA提供了新的更加健壮的线程处理机制,包括了同步、锁定、线程池等等,它们可以实现更小粒度上的控制。await()和signal()就是其中用来做同步的两种方法,它们的功能基本上和wait()/notify()相同,完全可以取代它们,但是它们和新引入的锁定机制Lock直接挂钩,具有更大的灵活性。
下面是一个例子代码:

    
  1. import java.util.LinkedList;
  2. import java.util.concurrent.locks.*;
  3. public class Sycn2{
  4. private LinkedList<Object> myList = new LinkedList<Object>();
  5. private int MAX = 10;
  6. private final Lock lock = new ReentrantLock();
  7. private final Condition full = lock.newCondition();
  8. private final Condition empty = lock.newCondition();
  9. public Sycn2(){
  10. }
  11. public void start(){
  12. new Producer().start();
  13. new Consumer().start();
  14. }
  15. public static void main(String[] args) throws Exception{
  16. Sycn2 s2 = new Sycn2();
  17. s2.start();
  18. }
  19. class Producer extends Thread{
  20. public void run(){
  21. while(true){
  22. lock.lock();
  23. try{
  24. while(myList.size() == MAX){
  25. System.out.println("warning: it's full!");
  26. full.await();
  27. }
  28. Object o = new Object();
  29. if(myList.add(o)){
  30. System.out.println("Producer: " + o);
  31. empty.signal();
  32. }
  33. }catch(InterruptedException ie){
  34. System.out.println("producer is interrupted!");
  35. }finally{
  36. lock.unlock();
  37. }
  38. }
  39. }
  40. }
  41. class Consumer extends Thread{
  42. public void run(){
  43. while(true){
  44. lock.lock();
  45. try{
  46. while(myList.size() == 0){
  47. System.out.println("warning: it's empty!");
  48. empty.await();
  49. }
  50. Object o = myList.removeLast();
  51. System.out.println("Consumer: " + o);
  52. full.signal();
  53. }catch(InterruptedException ie){
  54. System.out.println("consumer is interrupted!");
  55. }finally{
  56. lock.unlock();
  57. }
  58. }
  59. }
  60. }
  61. }

3.        阻塞队列方法BlockingQueue
BlockingQueue也是JDK5.0的一部分,它是一个已经在内部实现了同步的队列,实现方式采用的是我们的第2种await()/signal()方法。它可以在生成对象时指定容量大小。
它用于阻塞操作的是put()和take()方法。
put()方法类似于我们上面的生产者线程,容量最大时,自动阻塞。
take()方法类似于我们上面的消费者线程,容量为0时,自动阻塞。
下面是一个例子代码:

    
  1. import java.util.concurrent.*;
  2. public class Sycn3{
  3. private LinkedBlockingQueue<Object> queue = new LinkedBlockingQueue<Object>(10);
  4. private int MAX = 10;
  5. public Sycn3(){
  6. }
  7. public void start(){
  8. new Producer().start();
  9. new Consumer().start();
  10. }
  11. public static void main(String[] args) throws Exception{
  12. Sycn3 s3 = new Sycn3();
  13. s3.start();
  14. }
  15. class Producer extends Thread{
  16. public void run(){
  17. while(true){
  18. //synchronized(this){
  19. try{
  20. if(queue.size() == MAX)
  21. System.out.println("warning: it's full!");
  22. Object o = new Object();
  23. queue.put(o);
  24. System.out.println("Producer: " + o);
  25. }catch(InterruptedException e){
  26. System.out.println("producer is interrupted!");
  27. }
  28. //}
  29. }
  30. }
  31. }
  32. class Consumer extends Thread{
  33. public void run(){
  34. while(true){
  35. //synchronized(this){
  36. try{
  37. if(queue.size() == 0)
  38. System.out.println("warning: it's empty!");
  39. Object o = queue.take();
  40. System.out.println("Consumer: " + o);
  41. }catch(InterruptedException e){
  42. System.out.println("producer is interrupted!");
  43. }
  44. //}
  45. }
  46. }
  47. }
  48. }

你发现这个例子中的问题了吗?
如果没有,我建议你运行一下这段代码,仔细观察它的输出,是不是有下面这个样子的?为什么会这样呢?
warning: it's full!
Producer: java.lang.object@4526e2a
你可能会说这是因为put()和System.out.println()之间没有同步造成的,我也这样认为,我也这样认为,但是你把run()中的synchronized前面的注释去掉,重新编译运行,有改观吗?没有。为什么?
这是因为,当缓冲区已满,生产者在put()操作时,put()内部调用了await()方法,放弃了线程的执行,然后消费者线程执行,调用take()方法,take()内部调用了signal()方法,通知生产者线程可以执行,致使在消费者的println()还没运行的情况下生产者的println()先被执行,所以有了上面的输出。run()中的synchronized其实并没有起什么作用。
对于BlockingQueue大家可以放心使用,这可不是它的问题,只是在它和别的对象之间的同步有问题。
对于这种多重嵌套同步的问题,以后再谈吧,欢迎大家讨论啊!
4.        管道方法PipedInputStream/PipedOutputStream
这个类位于java.io包中,是解决同步问题的最简单的办法,一个线程将数据写入管道,另一个线程从管道读取数据,这样便构成了一种生产者/消费者的缓冲区编程模式。
下面是一个例子代码,在这个代码我没有使用Object对象,而是简单的读写字节值,这是因为PipedInputStream/PipedOutputStream不允许传输对象,这是JAVA本身的一个bug,具体的大家可以看sun的解释: http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4131126

    
  1. import java.io.*;
  2. public class Sycn4{
  3. private PipedOutputStream pos;
  4. private PipedInputStream pis;
  5. //private ObjectOutputStream oos;
  6. //private ObjectInputStream ois;
  7. public Sycn4(){
  8. try{
  9. pos = new PipedOutputStream();
  10. pis = new PipedInputStream(pos);
  11. //oos = new ObjectOutputStream(pos);
  12. //ois = new ObjectInputStream(pis);
  13. }catch(IOException e){
  14. System.out.println(e);
  15. }
  16. }
  17. public void start(){
  18. new Producer().start();
  19. new Consumer().start();
  20. }
  21. public static void main(String[] args) throws Exception{
  22. Sycn4 s4 = new Sycn4();
  23. s4.start();
  24. }
  25. class Producer extends Thread{
  26. public void run() {
  27. try{
  28. while(true){
  29. int b = (int) (Math.random() * 255);
  30. System.out.println("Producer: a byte, the value is " + b);
  31. pos.write(b);
  32. pos.flush();
  33. //Object o = new MyObject();
  34. //oos.writeObject(o);
  35. //oos.flush();
  36. //System.out.println("Producer: " + o);
  37. }
  38. }catch(Exception e){
  39. //System.out.println(e);
  40. e.printStackTrace();
  41. }finally{
  42. try{
  43. pos.close();
  44. pis.close();
  45. //oos.close();
  46. //ois.close();
  47. }catch(IOException e){
  48. System.out.println(e);
  49. }
  50. }
  51. }
  52. }
  53. class Consumer extends Thread{
  54. public void run(){
  55. try{
  56. while(true){
  57. int b = pis.read();
  58. System.out.println("Consumer: a byte, the value is " + String.valueOf(b));
  59. //Object o = ois.readObject();
  60. //if(o != null)
  61. //System.out.println("Consumer: " + o);
  62. }
  63. }catch(Exception e){
  64. //System.out.println(e);
  65. e.printStackTrace();
  66. }finally{
  67. try{
  68. pos.close();
  69. pis.close();
  70. //oos.close();
  71. //ois.close();
  72. }catch(IOException e){
  73. System.out.println(e);
  74. }
  75. }
  76. }
  77. }
  78. //class MyObject implements Serializable {
  79. //}
  80. }




文章来源: panda1234lee.blog.csdn.net,作者:panda1234lee,版权归原作者所有,如需转载,请联系作者。

原文链接:panda1234lee.blog.csdn.net/article/details/8520508

【版权声明】本文为华为云社区用户转载文章,如果您发现本社区中有涉嫌抄袭的内容,欢迎发送邮件进行举报,并提供相关证据,一经查实,本社区将立刻删除涉嫌侵权内容,举报邮箱: cloudbbs@huaweicloud.com
  • 点赞
  • 收藏
  • 关注作者

评论(0

0/1000
抱歉,系统识别当前为高风险访问,暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称,即可参与社区互动!

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符,设置后3个月内不可修改。