死鎖是否需要兩個線程等待每個其他資源？

Question

我有這個程序，其中兩個線程等待相同的鎖股票對象並導致程序掛起。但是Thread1不會爲Thread2鎖而放棄，反之亦然。如果這不是死鎖，這種情況叫什麼？

public class DeadlockSimulator { 
    public static void main(String[] args) { 

     Stock st = new Stock(); 
     Runnable p1 = new Producer(st); 
     Runnable c1 = new Consumer(st); 
     Thread t1 = new Thread(p1); 
     Thread t2 = new Thread(c1); 
     t1.start(); 
     t2.start(); 
    } 
} 

public class Producer implements Runnable{ 
    private final Stock st; 
    public Producer(Stock st) { 
     this.st=st; 
    } 
    @Override 
    public void run() { 
     try{ 
      while(true) 
       st.addStock(3); 
     } 
     catch(Exception e) 
     { 
      e.printStackTrace(); 
     } 
    } 
} 

public class Stock { 
    private int qoh; 
    public Stock() { 
    } 

    public synchronized int getStock(int required) throws InterruptedException 
    { 
     int take=0; 
     if(qoh> required) 
     { 
      qoh=qoh-required; 
      take=required; 
      //notify(); 
     } 
     else 
     { 
      wait(); 
     } 
     return take; 
    } 
    public synchronized void addStock(int stocks) throws InterruptedException 
    { 
     if(qoh >7) 
     { 
      wait(); 
     } 
     else 
     { 
      qoh=qoh+stocks; 
      System.out.println("Current Stock"+ qoh); 
     // notify(); 
     } 
    } 
    public int getorderLevel() 
    { 
     return this.qoh; 
    } 
} 

public class Consumer implements Runnable { 
    private final Stock st; 
    public Consumer(Stock st) { 
     this.st = st; 
    } 
    @Override 
    public void run() { 
     try { 
      while (true) { 
       int got = st.getStock(5); 
       System.out.println("Got =" + got); 
      } 
     } catch (Exception e) { 
      e.printStackTrace(); 
     } 
    } 
} 

Answer 1

你是對的：這不是一個死鎖的例子。
這是synchronization的一個例子，它是concurrency control的一種形式。
在Java中，生產者/消費者問題通常通過使用BlockingQueue來解決。