【多线程系列】经典面试题 面试官：使用多线程实现循环顺序打印 123-灵析社区

问题分析

• 多线程循环顺序打印 123？很明显，这个问题是考察我们对线程同步的掌握程度，一想到线程同步，我们可以想到 join、使用锁进行线程同步（synchronized、ReentrantLock等等）等等方式实现，下面我们按照这些思路一一进行实现。

实现思路

基于 join 实现

• join 的作用是阻塞当前线程，直到其它线程不再活动，因此我们可以按照这个思路让线程串行执行，顺序打印123。

    /**
     * 循环次数
     */
    private volatile static int loopNum = 5000;

    /**
     * volatile 保证内存可见性
     */
    private volatile static int currentValue = 1;
    
    /**
     * Join 可以保证线程顺序执行，可以通过 Join 的方式串行执行
     * 创建 5000 个线程，每个线程需要等待前一个线程执行完成，从而实现串行执行
     *
     * 思考：这里是采用直接创建循环次数的线程数，可以优化为只维护两个线程的方式，即首节点线程执行完成后创建新线程执行
     */
    private static void cyclePrintUseJoin() {
        Thread preThread = null;
        for (int i = 0; i < loopNum; i++) {
            preThread = new Thread(new JoinTask(preThread));
            preThread.start();
        }
    }

    static class JoinTask implements Runnable {
        private final Thread preThread;

        public JoinTask(Thread thread) {
            this.preThread = thread;
        }

        @Override
        public void run() {
            // 如果 preThread 不为空表示不是头节点线程需要等待 preThread 执行完成
            if (preThread != null) {
                try {
                    preThread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

            System.out.println(currentValue);
            if (currentValue == 3) {
                currentValue = 1;
            } else {
                currentValue++;
            }
        }
    }

• 这里留了一个问题给大家思考：这里是采用直接创建循环次数的线程数，可以优化为只维护两个线程的方式，即首节点线程执行完成后再创建新线程

基于 synchronized 实现

• 使用 synchronized 同步代码块进行同步，让多线程串行执行

    /**
     * 循环次数
     */
    private volatile static int loopNum = 5000;

    /**
     * volatile 保证内存可见性
     */
    private volatile static int currentValue = 1;

    private static final Object lockObj = new Object();
    
    /**
     * 使用 synchronized 串行执行代码块
     */
    private static void cyclePrintUseSynchronized() {
        new Thread(new SynchronizedTask()).start();
        new Thread(new SynchronizedTask()).start();
        new Thread(new SynchronizedTask()).start();
    }
    
    static class SynchronizedTask implements Runnable {
        @Override
        public void run() {
            while (true) {
                synchronized (Test1.class) {
                    if (loopNum < 0) {
                        return;
                    }
                    System.out.println(currentValue);
                    if (currentValue == 3) {
                        currentValue = 1;
                    } else {
                        currentValue++;
                    }
                    loopNum--;
                }
            }
        }
    }

升级版 Plus：保证指定数字由指定线程打印

• 上面线程打印 1 2 3 由哪一个线程打印并不能保证，面试官此时会问，如何让指定线程打印对应数字，这时候我们就需要把对应的数字绑定到对应线程，当打印的数字和线程绑定的数字相同时才进行打印。

    /**
     * 循环次数
     */
    private static int loopNum = 5000;

    /**
     * 当前打印数字
     */
    private static int currentValue = 1;

    private static final Object lockObj = new Object();
    
        /**
     * 使用 synchronized 串行执行代码块
     * 且对应线程只处理对应任务
     */
    private static void cyclePrintUseSynchronizedPlus() {
        new Thread(new SynchronizedTaskPlus(1)).start();
        new Thread(new SynchronizedTaskPlus(2)).start();
        new Thread(new SynchronizedTaskPlus(3)).start();
    }

    static class SynchronizedTaskPlus implements Runnable {
        private final int target;

        public SynchronizedTaskPlus(int target) {
            this.target = target;
        }

        @Override
        public void run() {
            while (true) {
                synchronized (lockObj) {
                    if (loopNum < 0) {
                        return;
                    }
                    if (currentValue != target) {
                        try {
                            // 这里为了避免过多的无效抢占锁，使当前线程 进入等待状态（获取到锁但打印的数字和线程的绑定的数字不一样）
                            lockObj.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println(currentValue);
                    if (currentValue == 3) {
                        currentValue = 1;
                    } else {
                        currentValue++;
                    }
                    loopNum--;
                    // 注：这里需要唤醒所有的线程，因为唤醒的线程可能不是目标线程，导致无效唤醒
                    lockObj.notifyAll();
                }
            }
        }
    }

基于 ReentrantLock 实现

• ReentrantLock 和 synchronized 实现方式基本一致，但有一些细微的区别：ReentrantLock 只能保证有序性，无法保证可见性，因此需要使用 volatile 修饰变量保证多线程间的可见性。

    /**
     * 循环次数
     */
    private volatile static int loopNum = 5000;

    /**
     * volatile 保证内存可见性
     */
    private volatile static int currentValue = 1;

    private static final ReentrantLock reentrantLock = new ReentrantLock();

    /**
     * 使用 ReentrantLock 串行执行代码块
     */
    private static void cyclePrintUseReentrantLock() {
        new Thread(new ReentrantLockTask()).start();
        new Thread(new ReentrantLockTask()).start();
        new Thread(new ReentrantLockTask()).start();
    }

    static class ReentrantLockTask implements Runnable {
        @Override
        public void run() {
            while (true) {
                reentrantLock.lock();
                try {
                    if (loopNum < 0) {
                        return;
                    }
                    System.out.println(currentValue);
                    if (currentValue == 3) {
                        currentValue = 1;
                    } else {
                        currentValue++;
                    }
                    loopNum--;
                } finally {
                    reentrantLock.unlock();
                }
            }
        }
    }

升级版 Plus：保证指定数字由指定线程打印

• 实现思路和方式可以参考 synchronized 案例中的实现。大家可以自己动手实现一下。
• 【多线程系列】高效的 CAS (Compare and Swap)
• 【多线程系列】CAS 常见的两个升级版本 CLH、MCS
• 【多线程系列】JUC 中的另一重要大杀器 AQS 抽象队列同步器
  

点赞 评论 收藏 目录

阅读量：2016

点赞量：0

收藏量:0