首先我们来看看同步与死锁：
所谓死锁。这是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.
从以上的程序执行，我们能够发现，两个线程都在等待对方的执行完毕。这样，程序也就无法继续执行。从而造成了死锁执行现象。
以下我们来看生产者与消费者问题：
所谓生产者与消费者问题，非常easy，过程就是生产者不断生产产品。消费者不断取走产品。
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();}}
所以我们知道。生产者每生产一个产品，删除产品的消费者，删除每个消费者产品。我们必须等待生产者生产。
