面试题多线程轮流打印ABC初试

最近一直在家看传智播客java视频，这几天正好学习到了多线程，在上网看资料的时候发现了一道多线程经典面试题，为了检验自己的水平，就做了下，并写了这篇博客记录。

题目要求：

    建立三个线程，A线程打印10次A，B线程打印10次B,C线程打印10次   C，要求线程同时运行，交替打印10次ABC。

具体代码：

public class PrintABC
{
    public static void main(String[] args)
    {
        ABC abc = new ABC();
        PrintA pa = new PrintA(abc);
        PrintB pb = new PrintB(abc);
        PrintC pc = new PrintC(abc);


        pa.start();
        pb.start();
        pc.start();
    }
}

class ABC
{
    private boolean flagA = false;
    private boolean flagB = false;
    private boolean flagC = true;

    public int countA = 0;
    public int countB = 0;
    public int countC = 0;
    public synchronized void printA()
    {
        System.out.print("printA被唤醒。。");
        if(this.flagC == true)
        {
            System.out.print("A..." );
            this.flagA = true;
            this.flagC = false;
            System.out.print(++countA+"   ");
        }
    }
    public synchronized void printB()
    {
        System.out.print("printB被唤醒。。");
        if(this.flagA == true )
        {
            System.out.print("B...");
            this.flagB = true;
            this.flagA = false;
            System.out.print(++countB +"   ");
        }
    }
    public synchronized void printC()
    {
        System.out.print("printC被唤醒。。");
        if(this.flagB == true)
        {
            System.out.print("C...");
            this.flagC = true;
            this.flagB = false;
            System.out.println(++countC );
        }
    }
}
class PrintA extends Thread
{
    ABC abc = null;
    PrintA(ABC abc)
    {
        this.abc = abc;
    }
    public void run()
    {
        while(true)
        {
            synchronized(abc)
            {
                abc.printA();
                abc.notify();
                if(abc.countA >= 10)
                    return;
                try
                {
                    abc.wait();
                }
                catch (InterruptedException ie)
                {
                    System.out.println(ie.getMessage());
                }

            }

        }
    //  System.out.println("活动的线程数：" +Thread.activeCount()+"...PrintA线程的状态是：" + this.getState());
    }
}
class PrintB  extends Thread
{
    ABC abc = null;
    PrintB(ABC abc)
    {
        this.abc = abc;
    }
    public void run()
    {
        while(true)
        {
            synchronized(abc)
            {

                abc.printB();
                abc.notify();
                if(abc.countB >= 10)
                    return;
                try
                {
                    abc.wait();
                }
                catch (InterruptedException ie)
                {
                    System.out.println(ie.getMessage());
                }
            }
        }               
    //  System.out.println("活动的线程数：" + Thread.activeCount()+"...PrintB线程的状态是：" + this.getState());
    }

}
class PrintC  extends Thread
{
    ABC abc = null;
    PrintC(ABC abc)
    {
        this.abc = abc;
    }
    public void run()
    {
        while(true)
        {
            synchronized(abc)
            {

                abc.printC();
                abc.notify();
                if(abc.countC >= 10)
                    return ; 
                try
                {
                    abc.wait();
                }
                catch (InterruptedException ie)
                {
                    System.out.println(ie.getMessage());
                }   
            }
        }
    //  System.out.println("活动的线程数：" +Thread.activeCount()+"...PrintC线程的状态是：" + this.getState());
    }
}

输出结果：

解题思路：

说下我的思路，这个程序当中建立了五个类，其中类ABC中有三个boolean类型的成员变量flagA、flagB、flagC，用来表示三个字母是否被打印，三个int的变量记录字母的打印状态，然后有三个成员函数用于判断字母的打印状态，并在符合条件时打印字母，并重置字母的打印状态。
然后类PrintA、PrintB、PrintC的思路相同，都是继承Thread类并重写run（）方法，为了方便调用类ABC的方法，三个类中都有一个ABC类型的成员变量，并在构造函数中被初始化。然后在run（）方法中，都是在while死循环中进行synchronized同步，同步用的锁也都是ABC类型的对象abc，然后在同步代码块中先调用类ABC的print方法，然后notify（）方法唤醒同一个锁中的其他线程，然后判断输出了几次字母，如果已经够10次了，就return来结束线程，否则，用wait（）方法来冻结线程，等待被再次唤醒。
在主类中，创建了ABC类型的对象，然后创建并开启了三个线程。

结语：

多线程的题目都比较复杂，而且notify（）方法唤醒线程时具有不确定性，所以，在调试的时候应该多用输出语句来判断线程的状态。