condition对象，这个对象的await()和singal()方法

使用stop()不安全。它会解除由线程获取的所有锁定，而且如果对象处于一种不连贯状态，那么其他线程能在那种状态下检查和修改它们。结果很难检查出真正的问题所在。suspend()方法容易发生死锁。调用suspend()的时候，目标线程会停下来，但却仍然持有在这之前获得的锁定。此时其他任何线程都不能访问锁定的资源，除非被"挂起"的线程恢复运行。对任何线程来说，如果它们想恢复目标线程，同时又试图使用任何一个锁定的资源，就会造成死锁。所以不应该使用suspend()。 正确的做法是而应在自己的Thread类中置入一个标志，指出线程应该活动还是挂起。若标志指出线程应该挂起，便用wait()命其进入等待状态。若标志指出线程应当恢复，则用一个notify()重新启动线程。jdk1.5后提供了condition对象，这个对象的await()和singal()方法也可以达到线程通信的效果。

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;


//同步与通信
public class ConditionCommunication {


/**
* @param args
*/
public static void main(String[] args) {

final Business business = new Business();

                //子线程

new Thread(
new Runnable(){
@Override
public void run() {
//Atomic包中AtomicInteger用于多个线程访问同一个类，操作同一个integer，可以防止并发
for(int i = 0; i < 50; i++){
business.sub(i);
}
}
}
).start();
//主线程
for(int i = 0; i < 50; i++){
business.main(i);
}
}


static class Business{
Lock lock = new ReentrantLock();
Condition conndition = lock.newCondition();
private boolean bShouldSub = true;
public synchronized void sub(int i){
lock.lock();
try{
while(bShouldSub){
try {
//this.wait();
conndition.await();
int x = 1 + 2;
} catch (Exception e) {
e.printStackTrace();
}
}
for(int j = 0; j < 10; j++){
System.out.println("sub thread sequece of "+i + " loop " + j);
}
bShouldSub = false;
//this.notify();
conndition.signal();
}finally{
lock.unlock();
}
}

public synchronized void main(int i){
lock.lock();
try{
//用while比if好，因为wait有可能是伪唤醒
while(!bShouldSub){
try {
//this.wait();
conndition.await();
} catch (Exception e) {
e.printStackTrace();
}
}
for(int j = 0; j < 100; j++){
System.out.println("main thread sequece of "+i + " loop " + j);
}
bShouldSub = true;
//this.notify();
conndition.signal();
}finally{
lock.unlock();
}
}
}

}