首先我们来看同步与死锁问题：
所谓死锁，就是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;
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();
}
}
}
然后是主类：