问题描述：一个工厂里，许多人在生产馒头，有一个篮子用来存放馒头，同时也有许多人在吃馒头，请你用程序写一个程序来体现这个过程。

友情提示：篮子只能放6个馒头、生产馒头共20个、

代码段1：

package thread;
//主运行程序
public class ProducerAndConsumer {
public static void main(String[] args) {
SynStack s = new SynStack();
Produce p = new Produce(s);
Consumer c = new Consumer(s);
new Thread(p).start();
new Thread(c).start();
}
}

代码段2：

package thread;
//馒头实体
public class WoTou {
@Override
public String toString() {
return ""+ id;
}
int id;
WoTou(int id) {
this.id=id;
}
}

代码段3：

package thread;
//篮子实体类
public class SynStack {
int index = 0;
WoTou[] wotou = new WoTou[6];
public synchronized void push(WoTou w) {
while(index == 6) {
try {
this.wait();//暂停当前线程，直到被唤醒
} catch(InterruptedException e) {
e.printStackTrace();
}
}
this.notifyAll();//唤醒当前所有线程,notify为唤醒当前线程
wotou[index] = w;
index++;
}
public synchronized WoTou pop() {
while(index == 0) {
try {
this.wait();
} catch(InterruptedException e) {
e.printStackTrace();
}
}
this.notifyAll();
index--;
return wotou[index];
}
}

代码段4：

package thread;
//生产实体类
public class Produce implements Runnable {
SynStack s;
Produce(SynStack s) {
this.s = s;
}
@Override
public void run() {
for (int i = 0; i < 20; i++) {
WoTou w = new WoTou(i);
s.push(w);
System.out.println("produce : " + w);
}
}
}

代码段5：

package thread;
//吃馒头实例类
public class Consumer implements Runnable{
SynStack s;
Consumer(SynStack s) {
this.s = s;
}
@Override
public void run() {
try {
Thread.sleep(1000);
} catch(Exception e) {
e.printStackTrace();
}
for(int i=0; i<20; i++) {
WoTou w = s.pop();
System.out.println("Consumer : " + w);
}
}
}

总结学习：

线程的同步就涉及到死锁的运用，

java的一个关键字--synchronized,用于锁定对象，可以是方法，也可以是代码块.

1.public synchronized void sava() {} 或者 2.Object(this){}    this为当前对象

注意：

一、当两个并发线程访问同一个对象object中的这个synchronized(this)同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。

     二、然而，当一个线程访问object的一个synchronized(this)同步代码块时，另一个线程仍然可以访问该object中的非synchronized(this)同步代码块。

     三、尤其关键的是，当一个线程访问object的一个synchronized(this)同步代码块时，其他线程对object中所有其它synchronized(this)同步代码块的访问将被阻塞。

     四、第三个例子同样适用其它同步代码块。也就是说，当一个线程访问object的一个synchronized(this)同步代码块时，它就获得了这个object的对象锁。结果，其它线程对该object对象所有同步代码部分的访问都被暂时阻塞。

  五、以上规则对其它对象锁同样适用.