Java多線程（同步與死鎖問題，生產者與消費者問題）

首先我們來看同步與死鎖問題：

所謂死鎖，就是A擁有banana，B擁有apple。

A對B說：你把apple給我，我就把banana給你。

B對A說：你把banana給我，我就把apple給你。

但是A和B都在等待對方的答復，那麼這樣最終的結果就是A得不到apple，B也得不到banana。這種死循環就是死鎖。

於是我們可以模擬上面的描述，寫出以下代碼：

類A代表A這個人，

public class A {
 public void say(){
  System.out.println("A said to B: if you give me the apple, I will give you the banana.");
 }
 public void get(){
  System.out.println("A get the apple.");
 }
}

類B代表B這個人，

public class B {
 public void say(){
  System.out.println("B said to A: if you give me the banana, I will give you the apple.");
 }
 public void get(){
  System.out.println("B get the banana.");
 }
}

類ThreadDeadLock代表死鎖類，

public class ThreadDeadLock implements Runnable{
 private static A a=new A();
 private static B b=new B();
 public boolean flag=false;
 public void run(){
  if(flag){
   synchronized(a){
    a.say();
    try{
     Thread.sleep(500);
    }catch(InterruptedException e){
     e.printStackTrace();
    }
    synchronized(b){
     a.get();
    }
   }
  }else{
   synchronized(b){
    b.say();
    try{
     Thread.sleep(500);
    }catch(InterruptedException e){
     e.printStackTrace();
    }
    synchronized(a){
     b.get();
    }
   }
  }
 }
}

下面是主類：

public class Main{
 public static void main(String[] args){
  ThreadDeadLock t1=new ThreadDeadLock();
  ThreadDeadLock t2=new ThreadDeadLock();
  t1.flag=true;
  t2.flag=false;
  Thread thA=new Thread(t1);
  Thread thB=new Thread(t2);
  thA.start();
  thB.start();
 }
}

程序運行結果：
A said to B: if you give me the apple, I will give you the banana.
B said to A: if you give me the banana, I will give you the apple.

從以上的程序運行，我們可以發現，兩個線程都在等待對方的執行完成，這樣，程序也就無法繼續執行，從而造成了死鎖運行現象。

下面我們來看生產者與消費者問題：

所謂生產者與消費者問題，很簡單，過程就是生產者不斷生產產品，消費者不斷取走產品。

Producer生產product，Consumer消費product。

於是，我們先定義product類：

public class Product {
 private String name="product";
 private boolean flag=false;
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public synchronized void set(String name){
  if(!flag){
   try{
    super.wait();
   }catch(InterruptedException e){
    e.printStackTrace();
   }
  }
  this.setName(name);
  try{
   Thread.sleep(300);
  }catch(InterruptedException e){
   e.printStackTrace();
  }
  flag=false;
  super.notify();
 }
 public synchronized void get(){
  if(flag){
   try{
    super.wait();
   }catch(InterruptedException e){
    e.printStackTrace();
   }
  }
  try{
   Thread.sleep(300);
  }catch(InterruptedException e){
   e.printStackTrace();
  }
  System.out.println(this.getName());
  flag=true;
  super.notify();
 }
}

這裡加入了等待與喚醒，並增加一個標志位flag，flag為true時，表示可以生產，但不能取走，此時如果線程執行到了消費者線程，則應該等待，如果flag為false，則表示可以取走，但是不能生產，如果生產者線程運行，則應該等待。

Producer類：

public class Producer implements Runnable{
 private Product product=null;
 public Producer(Product product){
  this.product=product;
 }
 public void run(){
  for(int i=0;i<50;++i){
   this.product.set("product");
  }
 }
}

Consumer類：

public class Consumer implements Runnable{
 private Product product=null;
 public Consumer(Product product){
  this.product=product;
 }
 public void run(){
  for(int i=0;i<50;++i){
   try{
    Thread.sleep(100);
   }catch(InterruptedException e){
    e.printStackTrace();
   }
   this.product.get();
  }
 }
}

然後是主類：

public class Main{
 public static void main(String[] args){
  Product product=new Product();
  Producer pro=new Producer(product);
  Consumer con=new Consumer(product);
  new Thread(pro).start();
  new Thread(con).start();
 }
}

於是我們知道，生產者每生產一個產品，消費者就取走一個產品，消費者每取走一個產品，就要等待生產者生產。