我们先通过一道面试题来了解传统的线程同步通信。
题目:
子线程循环10次，接着主线程循环100次，接着又回到子线程循环10次，
接着再回到主线程又循环100次，如此循环50次，请写出程序。
我没有看答案，先用自己的思路写了一段代码，有一些是借鉴传统的“生产者与消费者”的
多线程模型写出来的:
[java] view plain copy 在CODE上查看代码片派生到我的代码片
package cn.edu.hpu.test;
/**
* 要求的操作：
* 子线程循环10次，接着主线程循环100次，接着又回到子线程循环10次，
* 接着再回到主线程又循环100次，如此循环50次。
* **/
public class ThreadTest3 {
public static void main(String[] args) {
Output out =new Output();//循环输出类
//注意:这里要保证子线程和主线程类引入的是同一个Output对象
//不然无法共用两把“钥匙”
MainRunnable main=new MainRunnable(out);//主线程
SonRunnable son=new SonRunnable(out);//子线程
new Thread(son).start();//主线程启动
new Thread(main).start();//子线程启动
}
}
class Output{
//两把“钥匙”
static boolean mbegin=false;
static boolean sbegin=true;//第一次子线程开始执行，所以这里默认为true
//主线程循环打印的方法（不可被打断）
public synchronized void doMainWhile(int num) throws InterruptedException {
int i=0;//每次i都要初始化为0，供循环使用
while(mbegin==false){//如果子线程在执行，主线程要等待，直到子线程恢复主线程的钥匙
this.wait();
}
for (i = 1; i <=100; i++) {//开始循环(每次在方法里循环100次)
System.out.println("主线程执行了第"+i+"次循环,总循环为第"+num+"次");
if(i==100){
break;
}
}
if(i==100){//主线程循环打印完毕之后，要让位给子线程执行
sbegin=true;//子线程开始工作
mbegin=false;//主线程停止工作
this.notify();//通知其他线程开始工作
}
}
//子线程循环打印的方法（不可被打断）
public synchronized void doSonWhile(int num) throws InterruptedException {
int j=0;//每次i都要初始化为0，供循环使用
while(sbegin==false){//如果主线程在执行，子线程要等待，直到主线程恢复子线程的钥匙
this.wait();
}
for (j = 1; j <=10; j++) {//开始循环(每次在方法里循环10次)
System.out.println("子线程执行了第"+j+"次循环,总循环为第"+num+"次");
if(j==10){
break;
}
}
if(j==10){//子线程循环打印完毕之后，要让位给主线程执行
sbegin=false;//子线程停止工作
mbegin=true;//主线程开始
this.notify();//通知其他线程开始工作
}
}
}
class MainRunnable implements Runnable{
Output out =null;
MainRunnable(Output out){//将Output对象引入进来
this.out=out;
}
public void run() {
try {
//因为要执行50次要求的操作，每次操作主线程要执行2次，一共50*2=100次
for(int i=1;i<=100;i++){
out.doMainWhile(i%2==0?i/2:(i+1)/2);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
class SonRunnable implements Runnable{
Output out =null;
SonRunnable(Output out){
this.out=out;
}
public void run() {
try {
//因为要执行50次要求的操作，每次操作子线程要执行2次，一共50*2=100次
for(int i=1;i<=100;i++){
out.doSonWhile(i%2==0?i/2:(i+1)/2);
}
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
首先我是创建了一个循环类，然后使用这个循环类进行循环打印操作，而且针对子线程和主线程使用不同的方法去执行，
其中主线程的循环打印方法中，让其打印100次，然后子线程的循环打印方法中，让其打印50次，而且使用关键字synchronized
保证各自的方法不会被打断。
给主线程和子线程传入共同的Output对象，可以保证共用统一的静态全部变量(就是里面的两把“钥匙”)。
线程的执行规则就是，一开始先让子线程运行(主线程其实也运行了，只是mbegin变量为false让其阻塞了)，运行完其循环10次的
方法之后，改变sbegin和mbegin的值，并通知其它线程。此时子线程由于sbegin变量为false而阻塞，主线程由于mbegin变量为true
而开始运行，主线程执行完自己的100次循环之后，改变sbegin和mbegin的值，并通知其它线程。此时主线程由于mbegin变量为false
而阻塞，而子线程由于sbegin变量为true而开始运行...如此这般就完成了一轮循环。
保证种循环执行50次的控制，就在于每个线程自己的for循环，他们其实每次大循环中，各自执行了两遍自己的循环打印方法，所以
他们每个线程执行50*2=100次循环打印方法就可以了。
结果(图片太长只截取了一次循环的某三步):
后来，我用参数计数得出一共循环了50次的大循环，结果是正确的。
但是我个人认为我只是单纯的实现了这种效果，代码拓展新不好，写法有点屌丝，
控制线程运行和阻塞的方法也不是太好(用了两个全局变量mbegin和sbegin)=_=。
下面看一下人家提供的一种答案吧:
[java] view plain copy 在CODE上查看代码片派生到我的代码片
package cn.edu.hpu.test;
public class ThreadTest4 {
public static void main(String[] args) {
new ThreadTest4().init();
}
public void init()
{
final Business business = new Business();
new Thread(
new Runnable()
{
public void run() {
for(int i=0;i<50;i++)
{
business.SubThread(i);
}
}
}
).start();
for(int i=0;i<50;i++)
{
business.MainThread(i);
}
}
private class Business
{
boolean bShouldSub = true;//这里相当于定义了控制该谁执行的一个信号灯
public synchronized void MainThread(int i)
{
if(bShouldSub)
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
for(int j=1;j<=100;j++)
{
System.out.println(Thread.currentThread().getName() + ":i=" + i +",j=" + j);
}
bShouldSub = true;
this.notify();
}
public synchronized void SubThread(int i)
{
if(!bShouldSub)
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
for(int j=1;j<=10;j++)
{
System.out.println(Thread.currentThread().getName() + ":i=" + i +",j=" + j);
}
bShouldSub = false;
this.notify();
}
}
}
结果(也是图片太长只截取了一次循环的某三步):
实际上答案给出的方法和我自己写的差不多，也是创建一个共用的类去循环打印数据，并分别给
子线程和主线程提供一个循环打印的方法，和我不同的是，他们使用的是同一个共用变量去控制
线程的启动和阻塞，而我使用了两个，而且答案的代码格式和命名都比较规范，这一点要改进。
另外，除了使用以上方法外，还提供了一个使用JDK5的“并法库”的方法来解决此问题：
[java] view plain copy 在CODE上查看代码片派生到我的代码片
package cn.edu.hpu.test;
import java.util.concurrent.Executors;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.locks.Condition;
public class ThreadTest5 www.zhenlyule.cn
{
private static Lock lock = new ReentrantLock();
private static Condition subThreadCondition = lock.newCondition();
private static boolean bBhouldSubThread = www.yyzx66.cn/ false;
public static void main(String [] args)
{
ExecutorService threadPool = Executors.newFixedThreadPool(3);
threadPool.execute(new Runnable(){
public void www.egouyuLe.cn run()
{
for(int i=0;i<50;i++)
{
lock.lock();
try
{
if(!bBhouldSubThread)
subThreadCondition.await();
forwww.yinb666.cn (int j=0;j<10;j++)
{
System.out.println(Thread.currentThread().getName() + ",j=" + j);
}
bBhouldSubThread = false;
subThreadCondition.signal();
}catch(Exception e)
{
}
finally
{
lock.unlock();
}
}
}
});
threadPool.shutdown();
for(int i=0;i<50;i++)
{
lock.lock();
try
{
if(bBhouldSubThread)
subThreadCondition.await();
for(int j=0;j<10;j++)
{
System.out.www.huarenc88.cn/ println(Thread.currentThread().getName() + ",j=" + j);
}
bBhouldSubThread = true;
subThreadCondition.signal();
}catch(Exception e)
{
}
finally
{
lock.unlock();
}
}
}
}
至此，我们通过完成该面试题，可以充分理解什么是线程同步通信，其实就是
线程在同一时间运行，然后通过一些变量或手段去让线程之间进行相互交替的运行，
来达到我们使用多线程的目的。