同步和線程工作不正常

Question

我試圖做這樣的事情：

有是有一個名爲n和兩個方法put()和get()字段，設置n的值或檢索值類Q n。然後有兩個類Producer和Consumer。 Producer類有一個線程調用put和consumer類有一個線程調用get。我試圖用Object lock這是Singleton類的唯一實例LockClass.

所以要進行同步，這是我的班問：

public class Q { 

    int n; 

    public void put(int n){ 
     System.out.println("Put " + n); 
     this.n = n; 
    } 

    public int get(){ 
     System.out.println("Got " + n); 
     return n; 
    } 
} 

LockClass：

public class LockClass { 

     private static Object Lock = new Object(); 

     private LockClass(){ 

     } 


     public static Object getLock(){ 
      return Lock; 
     } 
    } 

消費者：

public class Consumer implements Runnable { 

    Thread t; 
    Q q; 


    public Consumer(Q q){ 
     this.q = q; 
     t = new Thread(this); 
     t.start(); 
    } 
    /* (non-Javadoc) 
    * @see java.lang.Runnable#run() 
    */ 
    @Override 
    public void run() { 
     // TODO Auto-generated method stub 
     while(true){ 

      synchronized(LockClass.getLock()){ 
       q.get(); 
      } 
      try { 
       System.out.println("Consumer slept"); 
       Thread.sleep(1000); 
       System.out.println("Consumer awake"); 

      } catch (InterruptedException e) { 
       // TODO Auto-generated catch block 
       e.printStackTrace(); 
      } 
     } 
    } 

} 

生產者：

public class Producer implements Runnable { 

    Q q; 
    Thread t; 
    int i; 

    public Producer(Q q){ 
     this.q = q; 
     t = new Thread(this); 
     t.start(); 
     i = 0; 
    } 
    /* (non-Javadoc) 
    * @see java.lang.Runnable#run() 
    */ 
    @Override 
    public void run() { 
     // TODO Auto-generated method stub 
     while(true){ 
      i++; 
      synchronized(LockClass.getLock()){ 
       q.put(i); 
      } 
      try { 
       System.out.println("Producer slept"); 
       Thread.sleep(1000); 
       System.out.println("Producer awake"); 
      } catch (InterruptedException e) { 
       // TODO Auto-generated catch block 
       e.printStackTrace(); 
      } 
     } 
    } 


} 

DemoClass：這個類的主要功能

public class DemoClass { 

    /** 
    * @param args 
    */ 
    public static void main(String[] args) { 
     // TODO Auto-generated method stub 
     Q q = new Q(); 

     Producer prod = new Producer(q); 
     Consumer cons = new Consumer(q); 
    } 

} 

所以，當我運行這個上面的代碼中，我得到的是這樣的：

Put 1 
Producer slept 
Got 1 
Consumer slept 
Consumer awake 
Producer awake 
Got 1 
Consumer slept 
Put 2 
Producer slept 
Consumer awake 
Producer awake 
Got 2 
Consumer slept 
Put 3 
Producer slept 
Consumer awake 
Producer awake 
Got 3 
Consumer slept 
Put 4 
Producer slept 

所以，我其實做的線程在生產者和消費者中睡眠，以便有足夠的時間進行上下文切換。現在，當兩個人都需要同時睡覺的時候，如果製片人先睡，它應該首先醒來。但正如我在輸出中看到的那樣，製片人首先睡覺，但仍然是消費者首先醒來，並且無論哪個線程首先被喚醒，都應該獲得鎖定，並且另一個線程應該等待鎖定被釋放。

爲什麼它不按我期待的方式工作？我錯過了什麼嗎？

Answer 1

睡眠超時不保證是嚴格的，所以一個線程可以稍後睡覺並提前喚醒絕對有效。

[...]受精度和系統計時器和調度程序

的準確性理論上它甚至有可能爲一個線程使動作兩次，而：從了Thread.sleep Java文檔報價第二個線程將會休眠。

如果你想兩個線程充當了一個又一個，使用等待通知機制：

生產

Object lock = LockClass.getLock(); 
synchronized(lock){ 
    q.put(i); 
    lock.notifyAll(); 
    lock.wait();  
} 

消費者

Object lock = LockClass.getLock(); 
synchronized(lock){ 
    q.get(i); 
    lock.notifyAll(); 
    lock.wait();  
} 

Answer 2

從DOC：

...但是，這些睡眠時間並不能保證是準確的，因爲它們受底層操作系統提供的設施的限制... 在任何情況下，您都不能假定調用睡眠 會暫停該線程爲精確的時間段指定

https://docs.oracle.com/javase/tutorial/essential/concurrency/sleep.html