面试算法题：三线程循环打印ABC

偏执的太偏执、 2022-02-13 14:11 216阅读 0赞

面试遇到三线程循环打印ABC的题目，当时没写出来，然后经过查阅，进行整理了一下。

# 1、题目 #

有A、B、C 三个线程，A线程 输出“A”，B线程 输出“B”，C线程 输出“C”，要求同时启动3个线程，按照顺序输出“ABC”，循环10次，请使用代码实现。

# 2、问题分析 #

1.  A、B、C 三个线程；这表示我们要使用多线程同步，有人说了这不废话吗。是的，笔者只是想说，多线程的实现，有几种方式，①继承Thread，②实现Runnable 接口、③实现Cannable接口
2.  A线程 输出“A”，B线程 输出“B”，C线程 输出“C”：这意味着，3个线程之间的执行体run()不同，要想打印的字符串不同有两种方式；
    
     *  ① 采用**静态方式**，直接打印
        
         *  这种方式，显然，需要3个不同的执行体，也就意味着，我们要**实现三个不同的线程类，即3个Class**
     *  ②采用**构造器参数动态传递方式**，将要打印ABC 分别作为参数变量传递进来打印
        
         *  这种方式，只需要1个共同的执行体，**也就是只需要实现一个线程类，即1个Class**。
3.  按照顺序输出“ABC”：这表示，我们要控制线程的顺序，控制线程的顺序有哪些？
    
     *  **采用共享标识** ，对循环的序号进行控制，如：循环总数 %3 的余数，来指定应该对应的哪一个线程
     *  **采用互斥锁** ：①synchronized和Obejct的wait()、notify，②ReentrantLock和Condition类await 、signal
     *  **采用原子类型变量** ：如，AtomicInteger
4.  循环打印10次：这说明，我们需要定义一个线程共享变量static int currentCount，这里不用volatile，是因为volatile,声明变量值的一致性；static声明变量的唯一性。这里需要的是循环打印，是有序的，所以该使用static才对

# 3、解题方案 #

网上有各种解题方案，我们一一分析一下

## 1> 通过线程独有属性来指定线程 ##

采用线程的独有变量，或使指定其名字，通过switch或者if 判读 循环变量。代码如下：

public class Test extends Thread { 
    	private static int currentCount = 0;
    	public Test(String name) { 
    		this.setName(name);
    	}
    
    	@Override
    	public void run() { 
    		while (currentCount < 30) { 
    			switch (currentCount % 3) { //通过currentCount%3的余数控制线程打印A、B、C的顺序
    			case 0:
                    //System.out.println("0:"+currentCount+"-"); 1
    				if ("A".equals(value)) { 
    					System.out.print(value);
    					currentCount++;
    				}
    				break;
    			case 1:
                    //System.out.println("0:"+currentCount+"-"); 2
    				if ("B".equals(value)) { 
    					System.out.print(value);
    					currentCount++;
    				}
    				break;
    			case 2:
                    //System.out.println("0:"+currentCount+"-"); 3
    				if ("C".equals(value)) { 
    					System.out.print(value);
    					currentCount++;
    				}
    				break;
    			}
    		}
    
    	}
    	public static void main(String[] args) { 
    		new Test("A").start();
    		new Test("B").start();
    		new Test("C").start();
    	}
    }

这种方式，其实3个线程并不是只执行了30次，它还有很多次并没有打印，不信，你可以将1,2,3处注释取消。

那问题来了，为什么最后是打印了10次循环呢？这是由于currentCount++ 只执行了30次，每执行一次currentCount++ ，必定只能打印一个字符，且currentCount 是一个自增长，那么ABC的顺序也是固定的。因此能打印出来正确的结果。但这种方式并不符合多线程的要求，因此不可取。

如果要想只执行 30 次， 那么需要对循环体进行加锁，以此来控制 count 的增长顺序。  
如下：

class demo implements Runnable { 
        private static int count = 1;
        private String lock = "abc";
    
        @Override
        public void run() { 
            synchronized (lock) { 
                while (count < 30) { 
                    switch (count % 3) { 
                        case 1:
                            System.out.printf("A");
                            break;
                        case 2:
                            System.out.printf("B");
                            break;
                        case 0:
                            System.out.printf("C");
                            break;
                    }
                    count++;
                }
            }
        }
    }
    public class Test { 
        public static void main(String[] args) { 
            Thread t1 = new Thread(new demo());
            Thread t2 = new Thread(new demo());
            Thread t3 = new Thread(new demo());
            t1.start();
            t2.start();
            t3.start();
        }
    }

## 2> 使用Synchronized和wait/notifyAll ##

public class Test { 
        public static void main(String[] args) { 
            new MyThread(0,"A").start();
            new MyThread(1,"B").start();
            new MyThread(2,"C").start();
        }
    }
    class MyThread extends Thread { 
    	private static int currentCount; // 线程共有，判断所有的打印状态
    	private static Object obj = new Object(); // 线程锁对象
        private int flag; // 0：打印A；1：打印B；2：打印C
        private String value; 
        
        public MyThread(int flag,String value) { 
            this.flag = flag;
            this.value=value;
        }
    
        @Override
        public void run() { 
            for (int i = 0; i < 10; i++) { 
                synchronized (obj) { 
                    while (currentCount % 3 != flag) { 
                        try { 
                            obj.wait();
                        } catch (InterruptedException e) { 
                            e.printStackTrace();
                        }
                    }
                    System.out.print(value); // 执行到这里，表明满足条件，打印
                    currentCount++;
                    obj.notifyAll(); // 调用notifyAll方法
                }
            }
        }
    }

## 3> 使用Lock和await/signalAll ##

此方式便是将上面代码中的synchronized 的锁机制替换为lock锁，如下：

public class Test { 
    	public static void main(String[] args) { 
    		new MyThread(0, "A").start();
    		new MyThread(1, "B").start();
    		new MyThread(2, "C").start();
    	}
    }
    
    class MyThread extends Thread { 
    	private static int currentCount; // 线程共有，判断所有的打印状态
    	private static Lock lock = new ReentrantLock(); // 线程共有，线程锁对象
    	private static Condition condition = lock.newCondition();
    	private int flag; // 0：打印A；1：打印B；2：打印C
    	private String value;
    
    	public MyThread(int flag, String value) { 
    		this.flag = flag;
    		this.value = value;
    	}
    
    	@Override
    	public void run() { 
    		for (int i = 0; i < 10; i++) { 
    			lock.lock();
    			while (currentCount % 3 != flag) { 
    				try { 
    					condition.await();
    				} catch (InterruptedException e) { 
    					 e.printStackTrace();
    				}
    			}
    			System.out.print(value); // 执行到这里，表明满足条件，打印
    			currentCount++;
    			condition.signalAll();
    			lock.unlock();
    		}
    	}
    }

以上代码采用的是一样是使用同一对象锁的方式。