先不多说，直接上个例子，著名的生产者消费者问题。
public class ProducerConsumer {
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();//消费者线程
}
}
/**
消费的物品---窝头
**/
class WoTou {
int id;
WoTou(int id) {
this.id = id;
}
public String toString() {
return "WoTou : " + id;
}
}
/**
消费的空间---堆栈
**/
class SyncStack {
int index = 0;
WoTou[] arrWT = new WoTou[6];
public synchronized void push(WoTou wt) {
while(index == arrWT.length) {//是while而不是if的原因，当wait被打断的时候依旧要检查下堆栈是否满了,否则，由于之前判断过index，从而会跳过判断而导致错误
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.notifyAll();
arrWT[index] = wt;
index ++;
}
public synchronized WoTou pop() {
while(index == 0) {
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
this.notifyAll();
index--;
return arrWT[index];
}
}
/**
生产者类
**/
class Producer implements Runnable {
SyncStack ss = null;
Producer(SyncStack ss) {
this.ss = ss;
}
public void run() {
for(int i=0; i<20; i++) {
WoTou wt = new WoTou(i);
ss.push(wt);
System.out.println("生产了：" + wt);
try {
Thread.sleep((int)(Math.random() * 200));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
/**
消费者类
**/
class Consumer implements Runnable {
SyncStack ss = null;
Consumer(SyncStack ss) {
this.ss = ss;
}
public void run() {
for(int i=0; i<20; i++) {
WoTou wt = ss.pop();
System.out.println("消费了: " + wt);
try {
Thread.sleep((int)(Math.random() * 1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}效果如图：
synchronized的引入，学过数据库系统和操作系统的朋友应该会有所了解，对于共享资源，当一个线程占用的时候不能被其他线程操作，和操作系统的原子操作的原理有些相似。
对于synchronized的理解：
synchronized(对象){
同步代码块
}
当是非static synchronized函数时，默认对象为this；当为是static synchronized函数时，默认为当前对象.class。
而wait,notify,notifyAll时，前面必须指定锁，即对象(原因：因为如果出现synchronized嵌套的时候会出错，这个好比一个游戏，一个锁是一组，只有在一组之内wait，notify，notifyAll有效，而对于另外一个组是无效的。)
wait的引入：例如上题堆栈中只能放6个窝头，但是当堆栈中有6个窝头的时候，生产者获得对象锁的时候就不能生产了，因此，生产者就会进入wait池，同时又会释放对象锁。
notify的引入：唤醒wait池中的一个线程（ps：只能唤醒别的线程，不能唤醒自己）
notifyall的引入：唤醒wait池中的所有线程
在最后，给大家说下wait和sleep的区别吧，个人理解：
1.wait是Object类中方法，会抛出InteruptException，sleep是Thread类中的方法，wait方法只用在获得对象锁得时候才能用，否则会抛异常；
2.wait方法会释放对象锁，但是sleep不会释放对象锁；
3.wait后的线程需要其他的线程去唤醒，但是sleep的线程在规定的时间后会自动唤醒。