【Java多线程与并发库】4.传统线程同步通信技术

我们先通过一道面试题来了解传统的线程同步通信。

题目:
子线程循环10次，接着主线程循环100次，接着又回到子线程循环10次，
接着再回到主线程又循环100次，如此循环50次，请写出程序。

我没有看答案，先用自己的思路写了一段代码，有一些是借鉴传统的“生产者与消费者”的
多线程模型写出来的:

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)=_=。

下面看一下人家提供的一种答案吧:

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的“并发库”的方法来解决此问题：

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
{
    private static Lock lock = new ReentrantLock();
    private static Condition subThreadCondition = lock.newCondition();
    private static boolean bBhouldSubThread = false;
    public static void main(String [] args)
    {
        ExecutorService threadPool = Executors.newFixedThreadPool(3);
        threadPool.execute(new Runnable(){
            public void run()
            {
                for(int i=0;i<50;i++)
                {
                    lock.lock();                    
                    try
                    {                    
                        if(!bBhouldSubThread)
                            subThreadCondition.await();
                        for(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.println(Thread.currentThread().getName() + ",j=" + j);
                    }
                    bBhouldSubThread = true;
                    subThreadCondition.signal();                    
                }catch(Exception e)
                {                        
                }
                finally
                {
                    lock.unlock();
                }                    
        }
    }
}

至此，我们通过完成该面试题，可以充分理解什么是线程同步通信，其实就是
线程在同一时间运行，然后通过一些变量或手段去让线程之间进行相互交替的运行，

来达到我们使用多线程的目的。

转载请注明出处：http://blog.csdn.net/acmman/article/details/52774603