NullPointerException異常

Question

可能重複：
I am getting NullPointerException inside Consumer

難道這被認爲是在生產中的錯誤，消費者方案？

這是我的監製類。

package com ; 

import java.util.concurrent.PriorityBlockingQueue; 

public class Producer extends CommonClass implements Runnable { 
    private SyncronizedStack stack; 
    private int producerNum; 

    Producer(PriorityBlockingQueue<Character> queue) { 
     this.queue = queue; 
    } 

    public void run() { 

     char ch; 

     for (ch = 'a'; ch <= 'f'; ch++) { 
      queue.add(ch); 
      System.out.println("Producer" + producerNum + "produced :" + ch); 
      try { 
       Thread.sleep((int) (Math.random() * 300)); 

      } catch (InterruptedException e) { 
       System.out.println("Error"); 
      } 

     } 

    } 

} 

這是我的消費類

package com ; 

import java.util.concurrent.PriorityBlockingQueue; 

public class Consumer extends CommonClass implements Runnable { 

    private int consumerNum; 

    Consumer(PriorityBlockingQueue<Character> queue) { 
     this.queue = queue; 
    } 

    public void run() { 
     char c; 
     for (int i = 0; i < 7; i++) { 
      try { 
       c = queue.take(); 
       System.out.println("Consumer" + consumerNum + "consumed:" + c); 
      } catch (Exception e1) { 
       e1.printStackTrace(); 
      } 
      try { 
       Thread.sleep((int) (Math.random() * 300)); 
      } catch (InterruptedException e) { 
       System.out.println("Error"); 
      } 
     } 

    } 
} 

這是我CommonClass

package com ; 

import java.util.concurrent.PriorityBlockingQueue; 

public class CommonClass { 

    PriorityBlockingQueue<Character> queue = null; 

} 

這是我的客戶端程序

package com ; 

import java.util.concurrent.PriorityBlockingQueue; 

public class SyncTest { 

    public static void main(String[] args) { 

     CommonClass cs = new CommonClass(); 

     PriorityBlockingQueue<Character> queue = new PriorityBlockingQueue<Character>(); 

     Producer p1 = new Producer(queue); 
     Thread t1 = new Thread(p1); 
     t1.start(); 

     Consumer c1 = new Consumer(queue); 
     Thread ct1 = new Thread(c1); 

     ct1.start(); 

    } 
} 

當我運行此我得到輸出

Producer0produced :a 
Consumer0consumed:a 

Producer0produced :b 
Consumer0consumed:b 

Producer0produced :c 
Consumer0consumed:c 

Producer0produced :d 
Consumer0consumed:d 

Producer0produced :e 
Producer0produced :f 
Consumer0consumed:e 
Consumer0consumed:f 

這是E和F字母的情況。

是否有這個輸出的任何問題？因爲我看到Producer0同時生成了兩個語句，然後同時跟着Consumer0消息語句爲字母e和f。

我擔心，這個代碼我會想念由生產者產生的任何信息？

請指教？

謝謝意見。

Answer 1

是否有這個輸出的任何問題？

沒有。您的生產者線程只是設法在消費者設法消費第一個產品之前生成第二個產品。這是完全自然的，特別是當你隨機睡覺時。

當然，你可能想給一個上限，以您的隊列 - 然後用offer而不是add檢測，其中隊列已滿的情況 - 但你顯示的輸出是罰款。

Answer 2

因爲我看到聲明Producer0同時產生了兩個時間，然後同時跟隨着Consumer0消耗語句中的字母e和f。

不，這是可以預料的。您正在演示多個線程的典型異步行爲。製片人在消費者睡覺時能夠出示2封信。

這是將要發生特別是考慮到兼顧生產者和消費者都在做隨機睡覺：

Thread.sleep((int) (Math.random() * 300)); 

但即使沒有睡覺，這種不對稱的行爲，預計螺紋程序。

Answer 3

這是一個錯誤？

答案 - 否發生這種情況是因爲您正在添加不必要的睡眠。

Thread.sleep((int) (Math.random() * 300)); 

我簡化了下面的Producer consumer的版本。

public class Example { 

public static class Producer implements Runnable { 
    private PriorityBlockingQueue<Character> queue; 

    Producer(PriorityBlockingQueue<Character> queue) { 
     this.queue = queue; 
    } 

    public void run() { 
     char ch; 
     for (ch = 'a'; ch <= 'f'; ch++) { 
      queue.put(ch); 
     } 
    } 
} 

public static class Consumer implements Runnable { 

    private PriorityBlockingQueue<Character> queue; 

    Consumer(PriorityBlockingQueue<Character> queue) { 
     this.queue = queue; 
    } 

    public void run() { 
     for (int i = 0; i < 7; i++) { 
      try { 
       System.out.println("Consumer take :" + queue.take()); 
      } catch (InterruptedException e) { 
       Thread.currentThread().interrupt();// Propagate interrupt 
      } 
     } 
    } 
} 

public static void main(String[] args) { 
    ExecutorService executorService = Executors.newFixedThreadPool(2); 
    PriorityBlockingQueue<Character> queue = new PriorityBlockingQueue<Character>(7); 
    executorService.execute(new Producer(queue)); 
    executorService.execute(new Consumer(queue)); 
    executorService.shutdown(); 
} 

}