面试题:线程A打印1-10数字,打印到第5个数字时,通知线程B

Posted enjoyitlife

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了面试题:线程A打印1-10数字,打印到第5个数字时,通知线程B相关的知识,希望对你有一定的参考价值。

此题考查的是线程间的通信方式。

  • 可以利用park/unpark实现
  • 可以利用volatile关键字实现
  • 可以利用synchronized结合wait notify实现
  • 可以利用JUC中的CountDownLatch实现
  • 可以利用Condition中的await signal 实现

代码示例

利用Park/Unpak实现线程通信

private void notifyThreadWithParkUnpark(){

        Thread thb  = new Thread("线程B"){
            @Override
            public void run() {
                LockSupport.park();
                System.out.println(Thread.currentThread().getName()+"启动了");
            }
        };
        Thread tha =new Thread("线程A"){
            @Override
            public void run() {
                for(int i=1;i<11;i++){
                    System.out.println(Thread.currentThread().getName()+i);
                    if(i==5){
                        LockSupport.unpark(thb);
                    }
                }
            }
        };
        thb.start();
        tha.start();
    }

park与unpark可以看做一个令牌,park就是等待令牌,unpark就是颁发一个令牌,另外需要注意的是park与unpark的调用次数不用一一对应,而且假如在同步代码块中调用park方法,线程会进入阻塞状态,但是不会释放已经占用的锁。

本例使用park使线程B进入阻塞等待状态,在线程A调用unpark并传入线程B的名称使线程B可以继续运行。

使用Volatile关键字实现线程通信

private static volatile boolean flag = false;

private void notifyThreadWithVolatile(){
        Thread thc= new Thread("线程C"){
            @Override
            public void run() {
                for (int i = 0; i < 10; i++) {
                    if(i==5){
                        flag=true;
                        try {
                            Thread.sleep(500L);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println(Thread.currentThread().getName()+i);
                }
            }
        };

        Thread thd= new Thread("线程D"){
            @Override
            public void run() {
                while (true){
                    // 防止伪唤醒 所以使用了while
                    while(flag){
                        System.out.println(Thread.currentThread().getName()+"收到通知");
                        break;
                    }
                }
            }
        };

        thd.start();
        try {
            Thread.sleep(1000L);
        } catch (Exception e) {
            e.printStackTrace();
        }
        thc.start();

    }

volatile表示的禁用CPU缓存,用volatile修饰的变量,会强制从主内存中读取变量的值。java内存模型中关于volatile也是有说明的,volatile只能保证可见性,但不能保证原子性。

本例通过在volatile来修饰一个标志位,线程C修改了该标志位,然后线程D就可以“看到”标志位的修改,从而实现互相通信。

使用Synchronized 集合wait notify实现线程间通信

private static final Object lock = new Object();

private void notifyThreadWithSynchronized(){
        Thread the = new Thread("线程E"){
            @Override
            public void run() {
                synchronized (lock){
                    for (int i = 0; i <10 ; i++) {
                        System.out.println(Thread.currentThread().getName()+i);
                        if(i==5){
                            lock.notify();
                        }
                    }
                }
            }
        };


        Thread thf = new Thread("线程F"){
            @Override
            public void run() {
                while(true){
                    synchronized (lock){
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName()+"启动了");
                    }
                }
            }
        };
        thf.start();
        try {
            Thread.sleep(500L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        the.start();

    }

synchronized修饰同步代码块,而wait notify notify必须是在synchronized修饰代码块中使用,否则会抛出监视器异常。

本实例定义一个对象锁,而线程F首先获取到互斥锁,在执行wait()方法时,释放已经持有的互斥锁,进入等待队列。而线程E执行获取到互斥锁开始执行,当1==5时,调用notify方法,就会通知lock的等待队列,然后线程E会继续执行,由于线程F此时还是获取不到互斥锁(因为被线程E占用),所以会在线程E执行完毕后,才能获取到执行权。

利用CountDonwLatch实现线程间通信

//      倒计时器
    private CountDownLatch cdl = new CountDownLatch(1);

private void notifyThreadWithCountDownLatch(){
        Thread thg = new Thread("线程G"){
            @Override
            public void run() {
                try {
                    cdl.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"启动了");
            }
        };

        thg.start();

        Thread thh = new Thread("线程H"){
            @Override
            public void run() {
                for (int i = 1; i < 11; i++) {
                    System.out.println(Thread.currentThread().getName()+i);
                    if(i==5){
                        cdl.countDown();
                    }
                }

            }
        };

        thh.start();
    }

本示例中使用了CountDownLatch倒计时器,利用了倒计时器的阻塞特性来实现等待。具体就是声明一个计数器为1的倒计时器,线程G调用await()方法进入等待,直到计数器为0的时候才能够进入执行,而线程H在i==5会将计数器减一,使其为0,此时线程G就会继续执行了。

利用Condition中的await和signal来实现

//      ReentrantLock+ condition
    private Lock rtl=new ReentrantLock();
    private Condition condition = rtl.newCondition();

private void notifyThreadWithCondition(){

        Thread thi = new Thread("线程I"){
            @Override
            public void run() {

                while (true){
                    rtl.lock();
                    try {
                        condition.await();
                        System.out.println(Thread.currentThread().getName()+"启动了");
                        break;
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }finally {
                        rtl.unlock();
                    }
                }
            }
        };


        Thread thj = new Thread("线程J"){
            @Override
            public void run() {
                rtl.lock();
                try {
                    for (int i = 0; i < 10; i++) {
                        System.out.println(Thread.currentThread().getName()+i);
                        if(i==5){
                            condition.signal();
                        }
                    }
                } finally {
                    rtl.unlock();
                }

            }
        };

        thi.start();
        try {
            Thread.sleep(500L);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        thj.start();
    }

本示例是结合ReentrantLock和Condition来进行控制线程间的执行顺序,Condition的await()和signal(),他们的语义和wait notify是一样的。区别是在synchronized代码块里调用wait notify。通过示例可以看到这中方法实现会不断的加锁与解锁,所以看起来稍微复杂些。

总结

通过以上代码看到通过volatile的方式是最简洁方便,用park与unpark方式是比较灵活,不用加锁或解锁,剩下的synchronized与Conditon都是用了锁,而CountDownLatch则是利用了计数器。

以上是关于面试题:线程A打印1-10数字,打印到第5个数字时,通知线程B的主要内容,如果未能解决你的问题,请参考以下文章

JS面试题--使用for循环打印1-10,每个数字出现的间隔约500ms

面试题编程题01-python打印水仙花数字

多个线程实现顺序打印数据,(可自定义线程一次打印数量和总数量)

剑指offer面试题 29. 顺时针打印矩阵

剑指offer面试题 29. 顺时针打印矩阵

经典面试题——两个线程交替打印奇数和偶数