前言：
我们都听说过生产者和消费者的例子吧，现在来模拟一下。生产者生产面包，消费者消费面包。假定生产者将生成出来的面包放入篮子中，消费者从篮子中取。这样，当篮子中没有面包时，消费者不能取。当篮子满了以后，消费者不能一直生产。
思考：
使用面向对象的思想进行分析，涉及的事物有：生产者、消费者、篮子和面包。两个线程有：生产者的生产行为、消费者的消费行为。
Bread面包类
class Bread{
int id;
Bread(int id){
this.id=id;
}
public String toString(){
return "Bread:"+id;
}
}SyncStack篮子类
在篮子中，一般先放入的面包最后才取出，因此这里可以模拟数据结构栈的操作，提供了两个方法push()和pop()。
这里，假定篮子的最大容量为6个面包。
class SyncStack{
int index=0;
Bread[] arrWT=new Bread[6];
//1、放入
public synchronized void push(Bread wt){
//装满了
//if(index==arrWT.length){ 防止发生异常之后，篮子满了仍然生成出现问题
while(index==arrWT.length){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//叫醒wait中的线程
this.notify();
//this.notifyAll(); //叫醒所有
arrWT[index]=wt;
index++;
}
//2、拿出
public synchronized Bread pop(){
//篮子空了
while(index==0){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.notify();
index--;
return arrWT[index];
};
}生产者和消费者
终于轮到线程类出场了！生产者Producer实现如下，消费者Consumer类也十分类似，只是不再具备生产面包的功能，并且将push方法换成了pop，在这里就不展示了。
class Producer implements Runnable{
//持有框的引用
SyncStack ss=null;
Producer(SyncStack ss){
this.ss=ss;
}
@Override
public void run() {
for (int i = 1; i < 20; i++) {
Bread wt=new Bread(i);
//扔到框里
ss.push(wt);
System.out.println("producer:"+wt);
try {
Thread.sleep((long) (Math.random()*1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
这里我们简单的测试一下，一个生产者和一个消费者。
public static void main(String[] args) {
SyncStack ss=new SyncStack();
Producer p=new Producer(ss);
Consumer c=new Consumer(ss);
new Thread(p).start();
new Thread(c).start();
}
基本符合前面的要求
分析：
1、synchronized
一种同步锁，可以修饰代码块、方法等。当一个线程访问其修饰的内容时，视图访问该对象的线程将被阻塞。举个小例子：
/**
* 获得当前时间
*/
public synchronized static void getTime() {
System.out.println("1、进入获取时间方法=====");
Date date = new Date();
DateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
String time = format.format(date);
System.out.println("2、"+Thread.currentThread().getName() + ":" + time);
System.out.println("3、获取时间成功=====");
System.out.println();
}
我们启100次线程去调用他，在没有加synchronized关键字时，截取部分打印结果如下图：
加上关键字之后，打印结果如下：
可以很容易看出，在该方法前加上synchronized关键字之后，其他线程如果想继续访问，就会被阻塞，等待该线程执行结束后，其他线程才可以继续访问。
在上面消费者和生成者的例子中，我们在SyncStack的push和pop方法前都加上了synchronized关键字，就是为了保证“放”和“取”的原子性，这样模拟的结果才是合理的。
那么有人可能会问，生产者生产馒头和消费者消费馒头是否需要保持原子性，同一时间只允许一个线程执行呢？结合实际情况，可能有多个生产者、消费者同时进行操作，因此，这里不应做限制。
2、sleep()和wait()
在上面的例子中，Producer和Consumer内部使用的Thread.sleep()方法，而在SyncStack中的push和pop中却是用的wait()方法。这两个方法看似功能类似，有什么差别呢？
首先，翻到他们的根去看定义。注释看不懂可以先不看，不过注释就把他们的区别都说明白了。
wait()
public class Object {
/**
* Causes the current thread to wait until another thread invokes the
* {@link java.lang.Object#notify()} method or the
* {@link java.lang.Object#notifyAll()} method for this object.
* In other words, this method behaves exactly as if it simply
* performs the call {@code wait(0)}.
* <p>
* The current thread must own this object's monitor.
*/
public final void wait() throws InterruptedException {
<span style="white-space:pre"> wait(0);</span>
}
}sleep()
public
class Thread implements Runnable {
/**
* Causes the currently executing thread to sleep (temporarily cease
* execution) for the specified number of milliseconds, subject to
* the precision and accuracy of system timers and schedulers. The thread
* does not lose ownership of any monitors.
*/
public static native void sleep(long millis) throws InterruptedException;
}
先说点肤浅的差别：
wait()是Object类中的方法，sleep()是Thread类中的。sleep必须指明挂起或睡眠的时间，而wait不需要。
上面注释中说的：
sleep()方法——占着CPU睡觉：CPU部分资源别占用，其他线程无法进入，但并不会失去他的监控，等到指定时间到了以后，继续恢复执行。
wait() 方法——等待使用CPU：线程会放弃对象锁，直到收到notify()通知才会进入准备状态。
我的理解：
在该实例中，push和pop中在“篮子空了”、“篮子装满了”的情况下使用了wait()方法。此时，已经无法继续工作下去，需要让出CPU给其他操作，才能保证生产-消费线进行。等到"篮子中有面包"情况时，调用notify通知线程执行。
Producer和Consumer中的sleep()方法是为了让放大彼此交替的差距，来接近现实生活的状态。