关于线程之间的通信问题

线程之间的通信需要用到notify()和wait()

注意这2个方法是Object的方法

使用对应对象的notify和wait方法时,需要拥有该对象的锁

下面大致解释下notify和wait方法

notify方法：

调用该方法可以唤醒一个由于对应对象的wait方法沉睡的线程

wait方法：

会使调用该方法的线程沉睡，并放弃持有的锁          注意与sleep区别 sleep不会放弃持有锁

下面利用该原理使多个线程循环有序打印A,BC..

先写一个线程类MyThread

该类存放前置锁和当前锁   执行完后利用前置锁使自身沉睡

需要注意的是第一次启动线程时由于线程之间没有阻塞关系会导致打印顺序出错

所以在一个线程的第一次执行时，后面线程不应该启动

mythread类：

public class MyThread implements Runnable {
private String pref;

private String self;
String name;
public  MyThread(String name,String self,String pref) {
// TODO Auto-generated constructor stub
this.self=self;
this.pref=pref;
this.name=name;
}

@Override
public void run() {
for(int i=0;i<10;i++){
synchronized (pref) {
System.out.println(name+"得到了锁"+pref);
synchronized (self) {
System.out.println(name+"得到了锁"+self);
self.notify();

try {
Thread.sleep(500);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
System.out.println(Thread.currentThread().getName()+":"+name+i);

}
try {
pref.wait();
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
// TODO Auto-generated method stub

}
}

测试方法：

public static void main(String[] args) throws InterruptedException {
MyThread A=new MyThread("A", "A", "F");
MyThread B=new MyThread("B", "B", "A");
MyThread C=new MyThread("C", "C", "B");
MyThread D=new MyThread("D", "D", "C");
MyThread E=new MyThread("E", "E", "D");
MyThread F=new MyThread("F", "F", "E");
Thread t1=new Thread(A);
t1.start();
Thread.sleep(600);   //为了确保t1线程已经一次执行并实现了对t1的阻塞
Thread t2=new Thread(B);
t2.start();
Thread.sleep(600);
Thread t3=new Thread(C);
t3.start();
Thread.sleep(600);
Thread t4=new Thread(D);
t4.start();
Thread.sleep(600);
Thread t5=new Thread(E);
t5.start();
Thread.sleep(600);
Thread t6=new Thread(F);
t6.start();
Thread.sleep(600);
}