java

关注公众号 jb51net

关闭
首页 > 软件编程 > java > Java 交替输出

Java多线程面试题之交替输出问题的实现

作者：小成同学_

本文主要介绍了Java多线程面试题之交替输出问题的实现，文中通过示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下

交替输出问题

image-20211015145725097

一定要保证交替输出，这就涉及到两个线程的同步问题。

有人可能会想到，用睡眠时间差来实现，但是只要是多线程里面，线程同步玩sleep()函数的，99.99%都是错的。

这道题其实有100多种解法。

最简单的解法

是这个问题的最优解，但其实不是面试官想听到的答案

关键函数

Locksupport.park()：阻塞当前线程
Locksupport.unpark("")：唤醒某个线程

LockSupport

package com.mashibing.juc.c_026_00_interview.A1B2C3
    
import java.util.concurrent.locks.LockSupport;

public class T02_00_LockSupport {
    
    static Thread t1 = null, t2 = null;
    
    public static void main(String[] args) throws Exception {
        char[] aI = "1234567".toCharArray();
        char[] aC = "ABCDEFG".toCharArray();
    
        t1 = new Thread(() -> {

                for (char c : aI) {
                    System.out.print(c);
                    LockSupport.unpark(t2); // 叫醒t2
                    LockSupport.park(); // t1阻塞 当前线程阻塞
                }

            }, "t1");

            t2 = new Thread(() -> {

                for (char c : aC) {
                    LockSupport.park(); // t2挂起
                    System.out.print(c);
                    LockSupport.unpark(t1); // 叫醒t1
                }

            }, "t2");

            t1.start();
            t2.start();
    }
}

在这里插入图片描述

执行程序：

image-20211227162406095

是我们想要的结果。

面试官想听到的解法

synchronized wait notify

package com.mashibing.juc.c_026_00_interview.A1B2C3

public class T06_00_sync_wait_notify {
    
    public static void main(String[] args) {

        final Object o = new Object();

        char[] aI = "1234567".toCharArray();
        char[] aC = "ABCDEFG".toCharArray();

        new Thread(() -> {
            // 首先创建一把锁
            synchronized (o) {
                for (char c : aI) {
                    System.out.print(c);
                    try {
                        o.notify(); // 叫醒等待队列里面的一个线程，对本程序来说就是另一个线程
                        o.wait(); // 让出锁
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                o.notify(); // 必须，否则无法停止程序
            }
        }, "t1").start();

        new Thread(() -> {
            synchronized (o) {
                for (char c : aC) {
                    System.out.print(c);
                    try {
                        o.notify();
                        o.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                o.notify();
            }
        }, "t2").start();
    }
}

可能有人会想，代码中的notify()和wait()顺序是不是没什么区别呢？那你就大错特错了，说明你不明白notify()和wait()是怎么执行的。

这道题其实是华为面试的填空题，让你填notify()和wait()。

image-20211227192836696

如果我们先执行wait()，会先让自己直接进入等待队列，自己和另一个线程都在等待队列中等待，两个线程大👁瞪小👁，在那傻等，谁也叫不醒对方，也就是根本执行不了notify()。

我们发现，在程序的后面还有一个notify()，而且还是必须有的，为什么是必须呢？我们将它注释掉，输出一下看看

image-20211227192149942

其实这是一个小坑。

虽然程序可以正常输出，但是程序没有结束；我们可以根据动图发现，最后一定是有一个线程是处在wait()状态的，没有人叫醒它，它就会永远处在等待状态中，从而程序无法结束，为了避免出现这种情况，我们要在后面加上一个notify()。

但是还有一个大坑！！！

玩过线程的应该早就发现了这个问题，如果第二个线程先抢到了，那么输出的就是A1B2C3了，怎么保证第一个永远先输出的是数字？

我们可以使用CountDownLatch这个类，它是JUC新的同步工具，这个类可以想象成一个门栓，当我们有线程执行到门这里，它会等待门栓把门打开，线程才会执行；如果t2抢先一步，那么它会执行await()方法，因为有门栓的存在，它只能在门外等待，所以t1线程会直接执行，执行到countDown()方法，使创建的CountDownLatch(1)参数置为0，即释放门栓，所以永远都是t1线程执行完，t2线程才会执行。

完整代码

package com.mashibing.juc.c_026_00_interview.A1B2C3

import java.util.concurrent.CountDownLatch;

public class T07_00_sync_wait_notify {

    private static CountDownLatch latch = new CountDownLatch(1); // 设置门栓的参数为1，即只有一个门栓

    public static void main(String[] args) {

        final Object o = new Object();

        char[] aI = "1234567".toCharArray();
        char[] aC = "ABCDEFG".toCharArray();

        new Thread(() -> {
            synchronized (o) {
                for (char c : aI) {
                    System.out.print(c);
                    latch.countDown(); // 门栓的数值-1，即打开门
                    try {
                        o.notify();
                        o.wait(); 
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                o.notify(); 
            }
        }, "t1").start();
        
        new Thread(() -> {
            try {
                latch.await(); // 想哪个线程后执行，await()就放在哪个线程里
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (o) {
                for (char c : aC) {
                    System.out.print(c);
                    try {
                        o.notify();
                        o.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                o.notify();
            }
        }, "t2").start();
    }
}

这样就解决了我们的担忧。

更灵活，更精细的解法

JDK提供了很多新的同步工具，在JUC包下，其中有一个专门替代synchronized的锁：Lock。

Lock ReentrantLock await signal

package com.mashibing.juc.c_026_00_interview.A1B2C3
    
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class T08_00_lock_condition {
    
        public static void main(String[] args) {

        char[] aI = "1234567".toCharArray();
        char[] aC = "ABCDEFG".toCharArray();

		Lock lock = new ReentrantLock();
        Condition condition = lock.newCondition();

        new Thread(() -> {
            
            lock.lock();
            
            try {
                for (char c : aI) {
                    System.out.print(c);
                    condition.signal();  // notify()
                    condition.await(); // wait()
                }
                condition.signal();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }, "t1").start();

        new Thread(() -> {
            lock.lock(); // synchronized
            try {
                for (char c : aC) {
                    System.out.print(c);
                    condition.signal(); // o.notify
                    condition.await(); // o.wait
                }
                condition.signal();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }, "t2").start();
    }
}

代码表面看起来，创建锁，调用方法跟synchronized没有区别，但是关键点在于Condition这个类，大家应该知道生产者和消费者这个概念，生产者生产馒头，生产满了进入等待队列，消费者吃馒头，吃光了同样进入等待队列，如果我们使用传统的synchronized，当生产者生产满时，需要从等待队列中叫醒消费者，但调用notify方法时，我们能保证一定叫醒的是消费者吗？不能，这件事是无法做到的，那该怎么保证叫醒的一定是消费者呢？

有两种解决方案：

① 如果篮子已经满了，生产者会去等待队列中叫醒一个线程，但如果叫醒的线程还是一个生产者，那么新的生产者起来之后一定要先检查一下篮子是否满了，不能上来就生产，如果是满的，那接着去叫醒下一个线程，这样依次重复，我们一定会有一次叫醒的是消费者。

② notifyAll()方法：将等待队列中的生产者和消费者全唤醒，消费者发现篮子是满的，就去消费，生产者发现篮子是满的，就继续回到等待队列。

但不管是这两个哪种解决方案，我们唤醒的线程都是不精确的，全都存在着浪费。

这就是synchronized做同步的问题。

image-20211230191645131

Lock本身就可以解决这个问题，靠的就是Condition，Condition可以做到精确唤醒。

Condition是条件的意思，但我们可以把它当做队列来看待。

一个condition就是一个等待队列。

标准代码

package com.mashibing.juc.c_026_00_interview.A1B2C3

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class T08_00_lock_condition {

    public static void main(String[] args) {

        char[] aI = "1234567".toCharArray();
        char[] aC = "ABCDEFG".toCharArray();

        Lock lock = new ReentrantLock();
        Condition conditionT1 = lock.newCondition(); // 队列1
        Condition conditionT2 = lock.newCondition(); // 队列2

        CountDownLatch latch = new CountDownLatch(1);
        new Thread(() -> {

            lock.lock(); // synchronized

            try {
                for (char c : aI) {
                    System.out.print(c);
                    latch.countDown();
                    conditionT2.signal();  // o.notify()
                    conditionT1.await(); // o.wait()
                }
                conditionT2.signal();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }, "t1").start();

        new Thread(() -> {

            try {
                latch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            lock.lock(); // synchronized

            try {
                for (char c : aC) {
                    System.out.print(c);
                    conditionT1.signal(); // o.notify
                    conditionT2.await(); // o.wait
                }
                conditionT1.signal();
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                lock.unlock();
            }
        }, "t2").start();
    }
}

image-20211230194107871

第一个线程t1先上来持有锁，持有锁之后叫醒第二队列的内容，然后自己进入第一队列等待，同理，t2线程叫醒第一队列的内容，自己进入第二队列等待，这样就可以做到精确唤醒。

到此这篇关于Java多线程面试题之交替输出问题的实现的文章就介绍到这了,更多相关Java 交替输出内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:
阅读全文