Java多线程学习（七）

时间  2019-11-05
标签 java 多线程 学习 栏目 Java 繁體版
原文   原文链接

等待/通知模式中最经典的案例当属生产者/消费者模式，此模式有几种变形，但都是基于wait/notify的。java

生产者/消费者模式有两种类型：操做值的和操做栈的。下面分别从这两方面来说解生产者/消费者模式。this

  1. 操做值线程

    ①一辈子产与一消费code

    public class P {
   private String lock;  //操做值
  public P(String lock){
       this.lock = lock;
  }
   public void setValue(){
        synchronized(lock){
           if(!ValueObject.value.equals("")){
                lock.wait();
           }
           String value = System.currentTimeMillis();
           ValueObject.value = value;
           lock.notify();
       }
   }
}
public class C {
   private String lock;  //操做值
   public C(String lock){
       this.lock = lock;
   }
   public void getValue(){
        synchronized(lock){
           if(ValueObject.value.equals("")){
                lock.wait();
           }
           ValueObject.value = "";
           lock.notify();
       }
   }
}
public class ValueObject {
   public static String value = "";
}
public class ThreadP extends Thread {
   private P p;
   public ThreadP(P p){
       this.p = p;
   }
   public void run(){
      while(true){
         p.setValue();
     }
   }
}
    
public class ThreadC extends Thread {
   private C c;
   public ThreadC(C c){
       this.c = c;
   }
   public void run(){
      while(true){
         c.getValue();
     }
   }
}  
public class Run{
   public static void main(String [] args){
      String lock = new String("");
     P p = new P(lock);
     C c = new C(lock);
     ThreadP tp = new ThreadP(p);
     ThreadC tc = new ThreadC(c);
     tp.start();
     tc.start();
  }
}
运行结果：不断地循环运行生产者的setValue方法和消费者的getValue方法，不停的交换数据。

    分析：tp线程首先运行，lock == “”，生产者p发现还没有生产，因此先生产，在下一次循环中发现value ！= “”；即生产出的产品还没有被消费，因此先等待进入wait状态。tc线程开始运行，发现 value！=“”，产品尚未被消费，因此先消费，在下一次循环中发现 value == “”，即生产者尚未生产，因此进入wait状态，让出控制权，让生产者继续生产...进入一种无限循环中。进程

    ②多生产与多消费：操做值--有可能进入假死状态rem

    public class P {
   private String lock;  //操做值
  public P(String lock){
       this.lock = lock;
  }
   public void setValue(){
        synchronized(lock){
           while(!ValueObject.value.equals("")){
                lock.wait();
           }
           String value = System.currentTimeMillis();
           ValueObject.value = value;
           lock.notify();
       }
   }
}
public class C {
   private String lock;  //操做值
   public C(String lock){
       this.lock = lock;
   }
   public void getValue(){
        synchronized(lock){
           while(ValueObject.value.equals("")){
                lock.wait();
           }
           ValueObject.value = "";
           lock.notify();
       }
   }
}
public class ValueObject {
   public static String value = "";
}
public class ThreadP extends Thread {
   private P p;
   public ThreadP(P p){
       this.p = p;
   }
   public void run(){
      while(true){
         p.setValue();
     }
   }
}
    
public class ThreadC extends Thread {
   private C c;
   public ThreadC(C c){
       this.c = c;
   }
   public void run(){
      while(true){
         c.getValue();
     }
   }
}  
public class Run{
   public static void main(String [] args){
      String lock = new String("");
     P p = new P(lock);
     C c = new C(lock);
     ThreadP tp1 = new ThreadP(p);
     ThreadP tp2 = new ThreadP(p);
     ThreadC tc1 = new ThreadC(c);
     ThreadC tc1 = new ThreadC(c);
     tp1.start();
     tc1.start();
     tp2.start();
     tc2.start();
   }
 }  
 运行结果：极有可能出现假死状况，即四个线程都处于wait状态。

    分析：首先生产者1在检查了条件，即value==“”后开始生产，而后调用notify方法，在下一次while循环检查条件是发现value ！= “”；进入wait状态；下一次若被生产者2抢到控制权，发现已经生产，则生产者2直接进入wait状态。而后消费者1检查发现value ！= “”，开始消费，在下一次while循环中，发现value == “”，即还没有生产，则进入wait状态，这时若消费者2抢到了锁， 也发现还没有生产，则也进入wait状态；生产者1又一次抢到了锁，开始生产，在下一次while循环中，发现还没有消费，进入了wait状态；此时若又由生产者2拿到了锁，它发现还没有消费，则也进入wait状态。如今，四个进程都在等待，进入了假死状态。get

    “假死”状态是由于线程连续唤醒同类形成的，生产者1唤醒生产者2，消费者1唤醒消费者2。如何解决？不只唤醒同类，并且将异类也一块儿唤醒。即将生产者和消费者中的notify方法换为notifyAll方法。产品

     

  2. 操做栈it

    ①一辈子产与一消费io

    public class MyStack {
       private List list = new ArrayList();     //操做栈
  3.        synchronized public void push(){
               if(list.size() == 1){
                       this.wait();
               }
               list.add("str");
               this.notify();
        }
        synchronized public void pop(){
               if(list.size() == 0){
                      this.wait();
               }
               list.remove(0);
               this.notify();
         }
}
public class P {
   private MyStack myStack;
   public P(MyStack s){
       this.myStack = s;
   }
   public void pushService(){
        myStack.push();
   }
}
public class C {
   private MyStack myStack;
   public C(MyStack s){
       this.myStack = s;
   }
   public void popService(){
        myStack.pop();
   }
}
public class ThreadP extends Thread {
   private P p;
   public ThreadP(P p){
       this.p = p;
   }
   public void run(){
      while(true){
         p.pushService();
     }
   }
}
    
public class ThreadC extends Thread {
   private C c;
   public ThreadC(C c){
       this.c = c;
   }
   public void run(){
      while(true){
         c.popService();
     }
   }
}  
public class Run{
   public static void main(String [] args){
      MyStack muStack= new MyStack();
      P p = new P(myStack);
      C c = new C(myStack);
      ThreadP tp = new ThreadP(p);
      ThreadC tc = new ThreadC(c);
      tp.start();
      tc.start();
   }
 }  
 运行结果：size不会超过1，生产和消费过程在轮流执行。

    分析：生产者首先运行，size==0，首先生产，在下一次while循环是进入wait状态；消费者运行，首先消费，在下一次while循环时发现还未生产，进入wait状态。唤醒生产者进行生产。。。不断循环此过程。

    ②一辈子产和多消费---可能遭遇条件改变抛出的异常和假死状况

    上例的代码不进行更改，只修改运行类以下：
public class Run{
   public static void main(String [] args){
      MyStack muStack= new MyStack();
      P p = new P(myStack);
      C c1 = new C(myStack);
      C c2 = new C(myStack);
      C c3 = new C(myStack);
      C c4 = new C(myStack);
      C c5 = new C(myStack);
      ThreadP tp = new ThreadP(p);
      ThreadC tc1 = new ThreadC(c1);
      ThreadC tc2 = new ThreadC(c2);
      ThreadC tc3 = new ThreadC(c3);
      ThreadC tc4 = new ThreadC(c4);
      ThreadC tc5 = new ThreadC(c5);
      tp.start();
      tc.start();
   }
}  
运行结果：在某些概率下出现异常IndexOutOfBoundException。

    分析：p1进行生产后进入wait状态；c1开始消费，消费后进入wait状态，假设此时消费者c二、c三、c四、c5都进入wait状态。p1有开始生产，而后唤醒c2进行消费后又进入wait状态，而后唤醒c3，因为代码中是if结构，从wait中醒来时不会再检查条件，而是直接进行remove操做，这时抛出异常。

    这是由于条件改变后没有获得即时的响应，解决这个问题的方法是，将if改成while语句便可；

     public class MyStack {
       private List list = new ArrayList();     //操做栈
       synchronized public void push(){
               while(list.size() == 1){
                       this.wait();
               }
               list.add("str");
               this.notify();
        }
        synchronized public void pop(){
               while(list.size() == 0){
                      this.wait();
               }
               list.remove(0);
               this.notify();
         }
}
运行结果：此次不会抛出异常，可是出现假死状况。

    分析：由于是while循环，那么消费者在检查条件后，优惠进入wait状态，这是生产者和全部的消费者都进入了wait状态。

    解决方法：将notify（）方法改成notifyAll（）方法便可。

      public class MyStack {
       private List list = new ArrayList();     //操做栈
  4.        synchronized public void push(){
               while(list.size() == 1){
                       this.wait();
               }
               list.add("str");
               this.notifyAll();
        }
        synchronized public void pop(){
               while(list.size() == 0){
                      this.wait();
               }
               list.remove(0);
               this.notifyAll();
         }
}
运行结果：此次不会抛出异常，页不会出现假死状况。程序会正常运行下去。

  5. 注明：最后一种while + notifyAll的类型一样适用于多生产者和一消费者，以及多生产者和多消费者这两种状况。

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程