我们现在需要实现建立三个线程，A线程打印10次A，B线程打印10次B,C线程打印10次C，要求线程同时运行，交替打印10次ABC。
理解：
Obj.wait()，与Obj.notify()必须要与synchronized(Obj)一起使用，也就是wait,与notify是针对已经获取了Obj锁进行操作，从语法角度来说就是Obj.wait(),Obj.notify必须在synchronized(Obj){...}语句块内。从功能上来说wait就是说线程在获取对象锁后，主动释放对象锁，同时本线程休眠。直到有其它线程调用对象的notify()唤醒该线程，才能继续获取对象锁，并继续执行。相应的notify()就是对对象锁的唤醒操作。但有一点需要注意的是notify()调用后，并不是马上就释放对象锁的，而是在相应的synchronized(){}语句块执行结束，自动释放锁后，JVM会在wait()对象锁的线程中随机选取一线程，赋予其对象锁，唤醒线程，继续执行。这样就提供了在线程间同步、唤醒的操作。Thread.sleep()与Object.wait()二者都可以暂停当前线程，释放CPU控制权，主要的区别在于Object.wait()在释放CPU同时，释放了对象锁的控制。
代码实现是：
public class PrintRunnable implements Runnable {
private int count = 10; private String name;
private Object pre;
private Object own;
public PrintRunnable(String name,Object pre,Object own) {
this.name = name;
this.pre = pre;
this.own = own; }
@Override
public void run() {
while(count > 0){
synchronized (pre) {
synchronized (own) {
System.out.print(name);
count--;
own.notify();
}
try {
pre.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
} }
测试代码是：
public class MainTest {
public static void main(String[] args) throws InterruptedException {
Object a = new Object();
Object b = new Object();
Object c = new Object();
Thread t1 = new Thread(new PrintRunnable("A", c, a));
Thread t2 = new Thread(new PrintRunnable("B", a, b));
Thread t3 = new Thread(new PrintRunnable("C", b, c));
t1.start();
Thread.sleep(100);
t2.start();
Thread.sleep(100);
t3.start();
Thread.sleep(100);
}
测试结果：
ABCABCABCABCABCABCABCABCABCABC
分析：
首先启动第一个线程，打印一个A，唤醒A锁，count--，（c.wait():释放C锁，第一个线程在循环中等待）。
其次启动第二个线程，打印一个B，唤醒B锁，count--，（a.wait():释放A锁，第二个线程在循环中等待）。
最后启动第三个线程，打印一个C，唤醒C锁，count--，（b.wait():释放B锁，第三个线程在循环中等待）。
由于第三个线程在循环中唤醒C锁，其执行完之后，会唤醒持有C锁等待的第一个线程，然后第一个线程执行完之后再唤醒循环中持有B锁的第二个线程，同理，依次执行唤醒操作。
资源均来自第三方，谨慎下载，前往第三方网站下载
