经典四道多线程问题

最新推荐文章于 2025-03-25 16:03:08 发布
最新推荐文章于 2025-03-25 16:03:08 发布
阅读量231 收藏 1
点赞数
文章标签： java 面试 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/zi2242975806/article/details/125273321
版权

关于线程同步的面试题，凡是从时间角度或者是优先级角度考虑解题思路的，基本全不对！凡是从join sleep考虑的，99.99%的不对. 线程优雅的结束，一般不用interrupt stop resume

最近新题，来自京东

给定文件，每行一词，统计词频（思考题）

基数统计？concurrent map (词 count) 大数据里面的word - count

多线程

Show Me The Difference (From Alibaba）

package com.mashibing.juc.c_35_QuestionsOfAlibaba;

public class ShowMeTheDifference {}

//4.指出以下两段程序的差别，并分析

final class Accumulator {
    private double result = 0.0D;
    public void addAll( double[] values) {
        for(double value : values) {
            result += value;
        }
    }
}

final class Accumulator2 {
    private double result = 0.0D;
    public void addAll( double[] values) {
        double sum = 0.0D;
        for(double value : values) {
            sum += value;
        }
        result += sum;
    }
}

答案：
第二种写法比第一种写法出现不一致性的概率要小，因为我们在方法完成之前，读不到中间状态的脏数据

尽量少暴露线程计算过程的中间状态

能用范围小的变量，不用范围大的变量

哲学家就餐问题

image.png

  1. 模拟哲学家问题 OOA - OOD - DDD
    class : 哲学家 class : 筷子
  2. 筷子：编号
  3. 哲学家：左手的筷子 右手的筷子 编号
package com.mashibing.juc.c_33_TheDinningPhilosophersProblem;


import com.mashibing.util.SleepHelper;

public class T01_DeadLock {
    public static void main(String[] args) {
        ChopStick cs0 = new ChopStick();
        ChopStick cs1 = new ChopStick();
        ChopStick cs2 = new ChopStick();
        ChopStick cs3 = new ChopStick();
        ChopStick cs4 = new ChopStick();

        Philosohper p0 = new Philosohper("p0", 0, cs0, cs1);
        Philosohper p1 = new Philosohper("p1", 1, cs1, cs2);
        Philosohper p2 = new Philosohper("p2", 2, cs2, cs3);
        Philosohper p3 = new Philosohper("p3", 3, cs3, cs4);
        Philosohper p4 = new Philosohper("p4", 4, cs4, cs0);

        p0.start();
        p1.start();
        p2.start();
        p3.start();
        p4.start();

    }

    public static class Philosohper extends Thread {

        private ChopStick left, right;
        private int index;

        public Philosohper(String name, int index, ChopStick left, ChopStick right) {
            this.setName(name);
            this.index = index;
            this.left = left;
            this.right = right;
        }

        @Override
        public void run() {
            synchronized (left) {
                SleepHelper.sleepSeconds(1 + index);
                synchronized (right) {
                    SleepHelper.sleepSeconds(1);
                    System.out.println(index + " 号 哲学家已经吃完");
                }
            }

        }

    }
}

死锁一般具有2把以上的锁，在锁定一把的时候等待另外一把锁

哲学家就餐问题解决方案：

  • 两把锁合并一把锁（5把， 5把锁合成一把锁，筷子集合，锁定整个对象）
  • 混进一个左撇子
  • 效率更高的写法，奇数 偶数分开，混进一半的左撇子
public void run() {
            //SleepHelper.sleepSeconds(new Random().nextInt(5));
            if (index == 0) { //左撇子算法 也可以index % 2 == 0

                synchronized (left) {
                    SleepHelper.sleepSeconds(1);
                    synchronized (right) {
                        SleepHelper.sleepSeconds(1);
                        System.out.println(index + " 吃完了！");
                    }
                }
            } else {
                synchronized (right) {
                    SleepHelper.sleepSeconds(1);
                    synchronized (left) {
                        SleepHelper.sleepSeconds(1);
                        System.out.println(index + " 吃完了！");
                    }
                }
            }
        }

交替输出问题

image.png

LockSupport

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();

Sync wait notify

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();

Lock ReentrantLock await signal

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();

生产者消费者问题 ReentantLock Condition

class Producer implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                //获取锁
                lock.lock();
                try {
                    while (count >= maxNum) {
                        producerCondition.await();
                        System.out.println("生产能力达到上限，进入等待状态");
                    }
                    count++;
                    System.out.println(Thread.currentThread().getName()
                            + "生产者生产，目前总共有" + count);
                    //唤醒消费者
                    consumerCondition.signalAll();
                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    //获取锁
                    lock.unlock();
                }
            }
        }
    }

    class Consumer implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(700);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                lock.lock();
                try {
                    while (count <= 0) {
                        consumerCondition.await();
                    }

                    count--;
                    System.out.println(Thread.currentThread().getName()
                            + "消费者消费，目前总共有" + count);
                    //唤醒生产者
                    producerCondition.signalAll();

                } catch (Exception e) {
                    e.printStackTrace();
                } finally {
                    lock.unlock();
                }
            }
        }
    }

异步回调回滚问题（分布式事务）

大任务分解成小任务，出错回滚问题（分布式事务）

package com.mashibing.juc.c_32_AliQuestions;

import com.mashibing.util.SleepHelper;

import java.util.ArrayList;
import java.util.List;

/**
 * 最原始的方法，Thread run()重写
 */

public class T00_F7 {

    private static class Boss extends Thread {
        private List<Worker> workers = new ArrayList<>();

        public void addTask(Worker t) {
            workers.add(t);
        }

        @Override
        public void run() {
            workers.stream().forEach((t) -> t.start());
        }

        public void end(Worker worker) {
            if (worker.getResult() == Result.FAILED) {
                cancel(worker);
            }
        }

        private void cancel(Worker worker) {
            for (Worker w : workers) {
                if (w != worker) w.cancel();
            }
        }


    }

    public static void main(String[] args) throws Exception {

        Boss boss = new Boss();
        Worker t1 = new Worker(boss, "t1", 3, true);
        Worker t2 = new Worker(boss, "t2", 4, true);
        Worker t3 = new Worker(boss, "t3", 1, false);

        boss.addTask(t1);
        boss.addTask(t2);
        boss.addTask(t3);

        //启动线程

        boss.start();

        System.in.read();
    }

    private static enum Result {
        NOTSET, SUCCESSED, FAILED, CANCELLED
    }

    private static class Worker extends Thread {

        private Result result = Result.NOTSET;

        private Boss boss;
        private String name;
        private int timeInSeconds;
        private boolean success;

        private volatile boolean cancelling = false;

        public Worker(Boss boss, String name, int timeInSeconds, boolean success) {
            this.boss = boss;
            this.name = name;
            this.timeInSeconds = timeInSeconds;
            this.success = success;
        }

        public Result getResult() {
            return result;
        }

        @Override
        public void run() {


            int interval = 100;
            int total = 0;

            for (; ; ) {
                SleepHelper.sleepMilli(interval); //cpu密集型
                total += interval;
                if (total / 1000 >= timeInSeconds) {
                    System.out.println(name + " 任务结束！" + result); //正常结束
                    result = success ? Result.SUCCESSED : Result.FAILED;
                    break;
                }

                if (cancelling) {
                    rollback();
                    result = Result.CANCELLED;
                    cancelling = false;
                    System.out.println(name + "任务结束！" + result);
                    break;
                }
            }


            //模拟业务执行时间
            //实际中时间不固定，可能在处理计算任务，或者是IO任务


            boss.end(this);
        }

        private void rollback() {
            //如何书写回滚？
            System.out.println(name + " rollback start...");
            SleepHelper.sleepMilli(500);
            System.out.println(name + " rollback end!");

        }


        public void cancel() {
            //思考一下，如何才能cancel？
            cancelling = true;
            //思考一下，在run中如何处理？
        }
    }


}

底层同步问题（乱序 和 屏障的问题）

  • CPU存在乱序执行
    ALU CPU内部运算单元 访问寄存器的速度，比访问内存的速度快100倍
package com.mashibing.dp.singleton;

import java.util.concurrent.ConcurrentHashMap;

/**
 * lazy loading
 * 也称懒汉式
 * 虽然达到了按需初始化的目的，但却带来线程不安全的问题
 * 可以通过synchronized解决，但也带来效率下降
 */
//DCL Double Check Lock
public class Mgr06 {
    private static volatile Mgr06 INSTANCE; //JIT

    private Mgr06() {
    }
    public static Mgr06 getInstance() {
        //业务逻辑代码省略
        if (INSTANCE == null) { //Double Check Lock
            //双重检查
            synchronized (Mgr06.class) {
                if(INSTANCE == null) {
                    INSTANCE = new Mgr06();
                }
            }
        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr06.getInstance().hashCode());
            }).start();
        }
    }
}
           //双重检查
            synchronized (Mgr06.class) {
                if(INSTANCE == null) {
                    INSTANCE = new Mgr06();
                }
            }
        }
        return INSTANCE;
    }

    public void m() {
        System.out.println("m");
    }

    public static void main(String[] args) {
        for(int i=0; i<100; i++) {
            new Thread(()->{
                System.out.println(Mgr06.getInstance().hashCode());
            }).start();
        }
    }
}
無言46
关注
38道多线程核心面试题（附答案）
Firstlucky77的博客
06-07 3万+
今天给大家分享的是比较全面的多线程面试题，大家在面试的过程中不免会被问到很多专业性的问题，有的时候回答的并不是那么全面和精细，这仅仅代表个人观点。1. 如何预防死锁？1.首先需要将死锁发生的是个必要条件讲出来互斥条件 同一时间只能有一个线程获取资源。不可剥夺条件 一个线程已经占有的资源，在释放之前不会被其它线程抢占请求和保持条件 线程等待过程中不会释放已占有的资源循环等待条件 多个线程互相等待对方释放资源2.死锁预防，那么就是需要破坏这四个必要条件：由于资源互斥是资源使用的固有特性，无法改变，我们不讨论破坏
50道多线程并发面试题
l688899886的博客
09-27 780
如果想要执行的线程有返回，可以使用Callable。CPU的缓存是以缓存行(cache line)为单位进行缓存的，当多个线程修改相互独立的变量，而这些变量又处于同一个缓存行时就会影响彼此的性能。这就是伪共享现代计算机计算模型:CPU执行速度比内存速度快好几个数量级，为了提高执行效率，现代计算机模型演变出CPU、缓存（L1，L2，L3），内存的模型。CPU执行运算时，如先从L1缓存查询数据，找不到再去L2缓存找，依次类推，直到在内存获取到数据。
哲学家问题（操作系统多线程经典问题）
01-18
叉子数量与哲学家数量一致 哲学家就餐需要两只叉子，因此相邻哲学家不可同时就餐 哲学家数量可以自定义
多线程经典问题
m0_52184592的博客
09-09 815
多线程经典问题,你能背出多少呢
【多线程】线程安全问题
我的博客
03-25 5869
本文详细探讨了多线程编程中的线程安全问题及其解决方案。线程安全是指程序在多线程环境下能够正确处理共享资源，确保数据的完整性和一致性。线程不安全的原因主要包括线程间的执行方式、多个线程修改同一个变量、操作的非原子性、内存可见性问题以及指令重排序问题。为了解决线程不安全问题，文章介绍了锁机制，通过`synchronized`关键字实现对共享资源的互斥访问，确保同一时间只有一个线程能操作临界区资源。文章还讨论了死锁的产生条件及解决方法，如规定加锁顺序、引入计数器等。此外，`volatile`关键字用于解决内存
Windows多线程（二）经典线程问题
水晶莲的专栏
09-10 727
声明：本文参考http://blog.youkuaiyun.com/morewindows/article/details/7442333
多线程经典问题 -- 生产问题
HLW0522的博客
07-08 415
//1生产者 1消费者 1缓冲区 //使用二个事件，一个表示缓冲区空，一个表示缓冲区满。 //再使用一个关键段来控制缓冲区的访问 #include #include #include //设置控制台输出颜色 BOOL SetConsoleColor(WORD wAttributes) { HANDLE hConsole = GetStdHandle(STD_OUTPUT_HANDLE);
多线程编程的几个经典问题
聪明的狐狸
11-19 2400
在最近的面试时，考察多线程编程时，除了经典的生产者-消费者，图书馆借书等问题，还遇到了以下几个考察多线程编程的经典问题，希望有时间能用C++/Python代码实现.   理发师问题： 一个理发店由一个有几张椅子的等待室和一个放有一张理发椅的理发室组成。 1．若没有要理发的顾客，则理发师去睡觉； 2．若一顾客进入理发店，理发师正在为别人理发，且等待室有空椅子，则该顾客就找张椅子按顺序坐下；
【多线程编程】59道多线程面试题详解：涵盖线程基础、同步机制、线程池及并发控制
最新发布
05-15
内容概要：本文档详细介绍了多线程编程的核心概念、常见问题及其解决方案。主要内容涵盖多线程的作用，如发挥多核CPU优势、防止阻塞和便于建模；线程与进程的区别；Java中实现多线程的方式；线程启动、终止、生命...
史上最全60道多线程面试题答案
02-09
多线程并发编程是Java编程中重要的一块内容，也是面试重点覆盖区域。所以，学好多线程并发编程对Java程序员来来说极其重要的。
多线程经典问题——生产者消费者精简总结(Java版)
风中一匹狼的博客
10-04 403
问题描述 有一个缓冲区，生产者往里生产东西，消费者从里消费东西。 缓冲区满时，生产者不能再生产；缓冲区空时，消费者不能再消费。 关键点 1、判断时必须用while不能用if，否则存在虚假唤醒问题。 虚假唤醒（个人理解）：多个同类正在wait，notify唤醒了同类。唤醒后的同类有可能会获得锁，则直接从wait开始继续往下执行了，而实际上此时可能并不满足生产或消费的条件，引发错误 2、两套东西，不能混用： synchronized+wait+notify lock+condition.await+con
秒杀多线程第四篇---一个经典的多线程同步问题
爱橙子的OK绷的专栏
11-12 961
上一篇《秒杀多线程第三篇原子操作 Interlocked系列函数》中介绍了原子操作在多进程中的作用，现在来个复杂点的。这个问题涉及到线程的同步和互斥，是一道非常有代表性的多线程同步问题，如果能将这个问题搞清楚，那么对多线程同步也就打下了良好的基础。程序描述：主线程启动10个子线程并将表示子线程序号的变量地址作为参数传递给子线程。子线程接收参数 -> sleep(50) -> 全局变量++ -> s
Java中的多线程—经典例题
智多
01-29 1294
经典例题1：生产者/消费者问题。 题目描述：生产者(Productor)将产品交给店员(Clerk)，而消费者(Customer)从店员处取走产品，店员一次只能持有固定数量的产品(比如:20），如果生产者试图生产更多的产品，店员会叫生产者停一下，如果店中有空位放产品了再通知生产者继续生产；如果店中没有产品了，店员会告诉消费者等一下，如果店中有产品了再通知消费者来取走产品。 public cl...
多线程经典问题2——子线程之间交替问题
lcx的专栏
08-13 1229
编写一个程序，开启3个线程，这3个线程的ID分别为A、B、C，每个线程将自己的ID在屏幕上打印10遍，要求输出结果必须按ABC的顺序显示；如：ABCABC….依次递推。 这个问题仍旧是线程间的交替控制问题，分析方法还是可以同上一篇“多线程经典问题1——主线程子线程交替问题”。
多线程问题
qq_35225231的博客
11-19 191
多线程问题解决总结
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值