java.util.concurrent包(3)——线程间通信wait/notify和await/signal

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

二、wait和notify实例
子线程循环10次，主线程循环100次。接着子线程循环10次，主线程循环100次。如此循环50次。摘自张孝祥老师线程视频源码。
public class TraditionalThreadCommunication
{
public static void main(String[] args)
{
final Business business = new Business();
new Thread(new Runnable() {
public void run()
{
for (int i = 1; i <= 50; i++)
{
business.sub(i);
}
}
}).start();
for (int i = 1; i <= 50; i++)
{
business.main(i);
}
}
}

class Business
{
private boolean bShouldSub= true;

public synchronized void sub(int i)
{
while (!bShouldSub)
{
try
{
this.wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
for (int j = 1; j <= 10; j++)
{
System.out.println("sub thread sequence of " + j + ",loop of " + i);
}
bShouldSub = false;
this.notify();
}

public synchronizedvoid main(int i)
{
while (bShouldSub)
{
try
{
this.wait();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
for (int j = 1; j <= 100; j++)
{
System.out.println("main thread sequence of " + j + ",loop of " + i);
}
bShouldSub = true;
this.notify();
}
}

三、Condition实例
public class Condition1Test
{
public static void main(String[] args)
{
final BusinessLock business = new BusinessLock();
new Thread(new Runnable() {
public void run()
{
for (int i = 1; i <= 50; i++)
{
business.sub(i);
}
}
}).start();
for (int i = 1; i <= 50; i++)
{
business.main(i);
}
}
}

class BusinessLock
{
private boolean bShouldSub = true;

ReentrantLock lock = new ReentrantLock();
Condition condition = lock.newCondition();

public void sub(int i)
{
lock.lock();
try
{
while (!bShouldSub)
{
try
{
condition.await();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
for (int j = 1; j <= 10; j++)
{
System.out.println("sub thread sequence of " + j + ",loop of " + i);
}
bShouldSub = false;
condition.signal();
}
finally
{
lock.unlock();
}
}

public void main(int i)
{
lock.lock();
try
{
while (bShouldSub)
{
try
{
condition.await();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
for (int j = 1; j <= 100; j++)
{
System.out.println("main thread sequence of " + j + ",loop of " + i);
}
bShouldSub = true;
condition.signal();
}
finally
{
lock.unlock();
}
}
}

四、Condition实例扩展
三个线程相互通信，main循环100次，sub2循环10次，sub3循环10次。接着main循环100次，sub2循环10次，sub3循环10次。如此循环50次。
public class Condition2Test
{
public static void main(String[] args)
{
final BusinessLock2 business = new BusinessLock2();
new Thread(new Runnable() {
public void run()
{
for (int i = 1; i <= 50; i++)
{
business.main(i);
}
}
}).start();

new Thread(new Runnable() {
public void run()
{
for (int i = 1; i <= 50; i++)
{
business.sub2(i);
}
}
}).start();

new Thread(new Runnable() {
public void run()
{
for (int i = 1; i <= 50; i++)
{
business.sub3(i);
}
}
}).start();
}
}


class BusinessLock2
{
private int bShouldSub = 1;

ReentrantLock lock = new ReentrantLock();
Condition condition1 = lock.newCondition();
Condition condition2 = lock.newCondition();
Condition condition3 = lock.newCondition();

public void main(int i)
{
lock.lock();
try
{
while (bShouldSub != 1)
{
try
{
condition1.await();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
for (int j = 1; j <= 100; j++)
{
System.out.println("main thread sequence of " + j + ",loop of " + i);
}
bShouldSub = 2;
condition2.signal();
}
finally
{
lock.unlock();
}
}

public void sub2(int i)
{
lock.lock();
try
{
while (bShouldSub != 2)
{
try
{
condition2.await();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
for (int j = 1; j <= 10; j++)
{
System.out.println("sub2 thread sequence of " + j + ",loop of " + i);
}
bShouldSub = 3;
condition3.signal();
}
finally
{
lock.unlock();
}
}

public void sub3(int i)
{
lock.lock();
try
{
while (bShouldSub != 3)
{
try
{
condition3.await();
}
catch (InterruptedException e)
{
e.printStackTrace();
}
}
for (int j = 1; j <= 10; j++)
{
System.out.println("sub3 thread sequence of " + j + ",loop of " + i);
}
bShouldSub = 1;
condition1.signal();
}
finally
{
lock.unlock();
}
}
}