一个线程协同问题，15个经典面试问题

最新推荐文章于 2024-11-15 18:38:47 发布
最新推荐文章于 2024-11-15 18:38:47 发布
阅读量74 收藏
点赞数
分类专栏： 程序员 文章标签： java 面试 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61452556/article/details/120144824
版权 
public static void main(String[] args) {
    Thread a = new Thread(() -> {
        Global1.var++;
        final ReentrantLock lock = reentrantLock;
        lock.lock();
        try {
            condition.signal();
        } finally {
            lock.unlock();
        }
    });
    Thread b = new Thread(() -> {
        final ReentrantLock lock = reentrantLock;
        lock.lock();
        try {
            condition.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }

        if (Global1.var == 2) {
            //do something;
            System.out.println(Thread.currentThread().getName() + " good job");
        }
    });
    a.start();
    b.start();
}

}

这个方案使用了Condition对象来实现object的notify、wait效果。当然，这个也有同样的问题。


# 正确解法1--基于错误解法2进行改进

我们看看，前面问题的根源在于，我们线程a，在去通知线程b的时候，有可能线程b还没开始wait，所以此时通知失效。

那么，我们是不是可以先等等，等线程b开始wait了，再去通知呢？

Thread a = new Thread(() -> {
        Global1.var++;
        final ReentrantLock lock = reentrantLock;
        lock.lock();
        try {
            // 1
            while (!reentrantLock.hasWaiters(condition)) {
                Thread.yield();
            }
            condition.signal();
        } finally {
            lock.unlock();
        }
    });

1处代码，就是这个思想，在signal之前，判断当前condition上是否有waiter线程，如果没有，就死循环；如果有，才去执行signal。

这个方法实测是可行的。


# 正确解法2

对正确解法1，换一个api，就变成了正确解法2.

Thread a = new Thread(() -> {
Global1.var++;
final ReentrantLock lock = reentrantLock;
lock.lock();
try {
// 1
while (reentrantLock.getWaitQueueLength(condition) == 0) {
Thread.yield();
}
condition.signal();
} finally {
lock.unlock();
}
});

1这里，获取condition上等待队列的长度，如果为0，说明没有等待者，则死循环。


# 正确解法3--基于Semaphore

刚开始，我们初始化一个信号量，state为0\. 线程b去获取信号量的时候，就会阻塞。

然后我们线程a再去释放一个信号量，此时线程b就可以继续执行。

public class Global1 {
public static volatile int var = 1;
public static final Semaphore semaphore = new Semaphore(0);

public static void main(String[] args) {
    Thread a = new Thread(() -> {
        Global1.var++;
        semaphore.release();
    });
    a.setName("thread a");
    Thread b = new Thread(() -> {
        try {
            semaphore.acquire();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        if (Global1.var == 2) {
            //do something;
            System.out.println(Thread.currentThread().getName() + " good job");
        }
    });
    b.setName("thread b");
    a.start();
    b.start();
}

}


# 正确解法4--基于CountDownLatch

public class Global1 {
public static volatile int var = 1;
public static final CountDownLatch countDownLatch = new CountDownLatch(1);

public static void main(String[] args) {
    Thread a = new Thread(() -> {
        Global1.var++;
        countDownLatch.countDown();
    });
    a.setName("thread a");
    Thread b = new Thread(() -> {
        try {
            countDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        if (Global1.var == 2) {
            //do something;
            System.out.println(Thread.currentThread().getName() + " good job");
        }
    });
    b.setName("thread b");
    a.start();
    b.start();
}

}


# 正确解法5--基于BlockingQueue

这里使用了ArrayBlockingQueue，其他的阻塞队列也是可以的。

import countdown.CountdownTest;

public class Global1 {
public static volatile int var = 1;
public static final ArrayBlockingQueue arrayBlockingQueue = new ArrayBlockingQueue(1);

public static void main(String[] args) {
    Thread a = new Thread(() -> {
        Global1.var++;
        arrayBlockingQueue.offer(new Object());
    });
    a.setName("thread a");
    Thread b = new Thread(() -> {
        try {
            arrayBlockingQueue.take();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        if (Global1.var == 2) {
            //do something;
            System.out.println(Thread.currentThread().getName() + " good job");
        }
    });
    b.setName("thread b");
    a.start();
    b.start();
}

}

# 正确解法6--基于FutureTask

我们也可以让线程b等待一个task的执行结果；而线程a在执行完修改var为2后，执行该任务，任务执行完成后，线程b就会被通知继续执行。

public class Global1 {
public static volatile int var = 1;
public static final FutureTask futureTask = new FutureTask(new Callable() {
@Override
public Object call() throws Exception {
System.out.println("callable task ");
return null;
}
});

public static void main(String[] args) {
    Thread a = new Thread(() -> {
        Global1.var++;
        futureTask.run();
    });
    a.setName("thread a");
    Thread b = new Thread(() -> {
        try {
            futureTask.get();
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        if (Global1.var == 2) {
            //do something;
            System.out.println(Thread.currentThread().getName() + " good job");
        }
    });
    b.setName("thread b");
    a.start();
    b.start();
}

}

# 正确解法7--基于join

这个可能是最简洁直观的，哈哈。也是群里同学们提供的解法，真的有才！

public class Global1 {
public static volatile int var = 1;

public static void main(String[] args) {
    Thread a = new Thread(() -> {
        Global1.var++;
    });
    a.setName("thread a");
    Thread b = new Thread(() -> {
        try {
            a.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        if (Global1.var == 2) {
            //do something;
            System.out.println(Thread.currentThread().getName() + " good job");
        }
    });
    b.setName("thread b");
    a.start();
    b.start();
}

}


# 正确解法8--基于CompletableFuture

这个和第6种类似。都是基于future。

public class Global1 {
public static volatile int var = 1;
public static final CompletableFuture completableFuture =
new CompletableFuture();

public static void main(String[] args) {
    Thread a = new Thread(() -> {
        Global1.var++;
        completableFuture.complete(new Object());
    });
    a.setName("thread a");
    Thread b = new Thread(() -> {
        try {
            completableFuture.get();
        } catch (InterruptedException | ExecutionException e) {
            e.printStackTrace();
        }

        if (Global1.var == 2) {
            //do something;
            System.out.println(Thread.currentThread().getName() + " good job");
        }
    });
    b.setName("thread b");
    a.start();
    b.start();
}

}

# 非阻塞--正确解法9--忙等待

这种代码量也少，只要线程b在变量为1时，死循环就行了。

public class Global1 {
public static volatile int var = 1;

public static void main(String[] args) {
    Thread a = new Thread(() -> {
        Global1.var++;
    });
    a.setName("thread a");
    Thread b = new Thread(() -> {
        while (var == 1) {
            Thread.yield();
        }

        if (Global1.var == 2) {
            //do something;
            System.out.println(Thread.currentThread().getName() + " good job");
        }
    });
    b.setName("thread b");

面试题总结

CodeChina开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频】

其它面试题（springboot、mybatis、并发、java中高级面试总结等）

job");
}
});
b.setName(“thread b”);

面试题总结

CodeChina开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频】

其它面试题（springboot、mybatis、并发、java中高级面试总结等）

[外链图片转存中…(img-nbxxM1fK-1630933537230)]

[外链图片转存中…(img-YBqAw524-1630933537232)]

架构师学习Java
关注
专栏目录
【面试必过系列，15个经典面试问题及回答思路
m0_61452476的博客
09-06 1403
为什么说简历很重要？ 一份好的简历可以在整个申请面试以及面试过程中起到非常好的作用。 在不夸大自己能力的情况下，写出一份好的简历也是一项很棒的能力。为什么说简历很重要呢? 先从面试前来说 假如你是网申，你的简历必然会经过HR的筛选，一张简历HR可能也就花费10秒钟看一下，然后HR就会决定你这一关是Fail还是Pass。 假如你是内推，如果你的简历没有什么优势的话，就算是内推你的人再用心，也无能为力。 另外，就算你通过了筛选，后面的面试中，面试官也会根据你的简历来判断你究竟是否值得他花费很多时间去面
java多线程编程面试题总结
weixin_43739821的博客
03-24 1470
新建 T1、T2、T3 三个线程，如何保证它们按顺序执行？ 在 java 中 wait 和 sleep 方法的不同？ 如何停止一个正在运行的线程？ synchronized关键字的底层原理 谈谈 JMM（Java 内存模型） CAS volatile AQS ReentrantLock的实现原理 synchronized和Lock有什么区别 ? 死锁产生的条件是什么？如何进行死锁诊断？ ConcurrentHashMap 并发程序出现问题的根本原因(并发三大特性) ThreadLocal
一个线程协同问题，解法多种，趁还没被玩坏赶快开动小脑瓜解决掉他，你应该没问题吧？？
m0_58476806的博客
05-23 177
###前言 不知道大家有没有感觉，小学初中读的一些书，看的一些文章，到现在都印象深刻，反倒是高中学的知识，高考后就慢慢消散，直到遗忘。 我想说的是，记得初中学过鲁迅的《藤野先生》，里面有一段话，大意是：久了不联系，有时候想联系，却又无从下笔，到最后就更是不了了之了。 我找了下原文： 将走的前几天，他叫我到他家里去，交给我一张照相，后面写着两个字道：“惜别”，还说希望将我的也送他。但我这时适值没有照相了;他便叮嘱我将来照了寄给他，并且时时通信告诉他此后的状况。 我离开仙台之后，就多年没有照过相，又因为状况也
32岁的程序员被裁，一个线程协同问题(1)
m0_60388216的博客
08-04 100
try { // 1 while (!reentrantLock.hasWaiters(condition)) { Thread.yield(); } condition.signal(); } finally { lock.unlock(); } }); 1处代码，就是这个思想，在signal之前...
15个Java线程并发面试题和答案
seeseeyoua的博客
11-15 145
我认为，这是最棒的 Java 线程面试问题之一，而且可以测试出面试者解决竞态条件的经验，或是编写无数据竞争、无其竞态条件的代码经验。并且可以根据面试者的代码问很多后续问题，如果他用 wait() 和 notify() 方法成功实现了阻塞队列，可以让他用 Java 5 的并发类重新实现一次。如果直接调用 run() 方法，并不会创建新线程，方法中的代码会在当前调用者的线程中执行。这是我最喜欢的 Java 多线程面试题，因为即使死锁在多线程并发编程中十分常见，许多面试者仍然抓耳挠腮，不能写出无死锁的代码。
JVM高频基本面试问题整理
张彦峰的博客
01-16 82万+
JVM一些基本问题的总结分享
多个线程之间如何协同
码农小胖哥
07-06 1004
1. CountDownLatch 计数器在多线程协作完成任务的时候，有时候需要等待其他线程完成任务后，主线程才能继续执行，我们可以使用Thread类的join()方法，让主线程等待被 join 的线程执行完毕主线程再执行。当然也可以通过线程的消息通信实现，但是今天我们 的并发包里面有一个工具，十分方便的完成这个任务。举个通俗的例子，二狗子带兵打仗，一共 6 个小...
每个程序员都会遇到的面试问题：谈谈进程和线程的区别
band_mmbx的博客
09-20 176
先到的人锁上门，后到的人看到上锁，就在门口排队，等锁打开再进去。线程可以看做轻量级的进程，同一类线程共享代码和数据空间，每个线程都有自己独立的运行栈和程序计数器（PC），线程之间切换的开销小。进程是程序的一次执行过程，是一个动态概念，是程序在执行过程中分配和管理资源的基本单位，每一个进程都有一个自己的地址空间，至少有 5 种基本状态，它们是：初始态，执行态，等待状态，就绪状态，终止状态。：没有线程的进程可以看做是单线程的，如果一个进程内有多个线程，则执行过程不是一条线的，而是多条线（线程）共同完成的；
一道多线程协同面试题的三种解决方案
dhaibo1986的专栏
09-13 426
最近看到一道线程协同的阿里面试题。 （JAVA）有3 个独立的线程，一个只会输出A，一个只会输出L，一个只会输出I。 在三个线程同时启动的情况下，请用合理的方式让他们按顺序打印ALIALI。 三个线程开始正常输出后，主线程若检测到用户任意的输入则停止三个打印线程的工作，整体退出。 这个题目实际上是在考察线程间协调。鉴于前面学习的线程间通信的三种方法，现在用三种方法来完成该问题。 1.synchronized 配合 wait/notify 首先用最经典的synchronized来实现。 import jav
10万字208道Java经典面试题总结(附答案)
热门推荐
学Java，找哪吒
08-02 101万+
1、JDK 和 JRE 有什么区别？ JDK（Java Development Kit），Java开发工具包 JRE（Java Runtime Environment），Java运行环境 JDK中包含JRE，JDK中有一个名为jre的目录，里面包含两个文件夹bin和lib，bin就是JVM，lib就是JVM工作所需要的类库。 2、== 和 equals 的区别是什么？ 对于基本类型，==比较的是值； 对于引用类型，==比较的是地址； equals不能用于基本类型的比较； 如果没有重写equa
一个线程协同问题，解法繁多，趁还没被玩坏赶快解决掉他
2401_84408337的博客
04-20 882
/ 1// 2});a.start();b.start();大家觉得这个代码能行吗？实际是不行的。因为实际的顺序可能是：线程a–1线程a–2线程b–1线程b–2在线程a-2时，线程a去notify，但是此时线程b还没开始wait，所以此时的notify是没有任何效果的：没人在等，notify个锤子。怎么修改，本方案才行得通呢？
并发复习：面试/笔试之多线程面试问题集锦
无休居士的博客
11-15 398
找工作告一段落，期间经历了很多事情，也思考了许多问题，最后也收获了一些沉甸甸的东西 —— 成长和一些来自阿里、百度、京东(sp)、华为等厂的Offer。好在一切又回到正轨，接下来要好好总结一番才不枉这段经历，遂将此过程中笔者的一些笔试/面试心得、干货发表出来，与众共享之。本文对面试/笔试过程中经常会被问到的一些关于并发编程的问题进行了梳理和总结，包括线程池、并发控制锁、并发容器和队列同步器等基础知识点，一方面方便自己温故知新，另一方面也希望为找工作的同学们提供一个复习参考。
搞定 HR 面试的 40 个必备问题！.zip
09-26
20. 处理复杂问题的能力：举例说明你如何解决一个复杂的 Java 技术问题，如多线程同步、大数据处理等。 以上问题的回答都需要结合 Java 技术知识来阐述，以展示你作为 Java 开发者的专业素养。准备充分的 HR 面试...
2021年开发就业面试问题-精简版x_2020教资面试成绩
01-08
例如，当一个结账柜台（服务器）出现问题时，其他柜台仍能继续服务，确保系统的稳定运行。 **3. 分布式系统** 分布式系统将不同功能模块部署在独立的服务器上，使得系统的维护不会影响整体服务。分布式系统强调模块...
日常bug记录，easyexcel导入报错convert data ... to class java.math.BigDecimal error
mm
11-11 307
排查发现实体类中有BigDecimal属性，然而数据中这个属性为null，进行转换时报错。在实体类上加上自定义转换器。解决方法：自定义转换器类。
Mybatis
最新发布
庸不易的博客
11-15 397
1、定义不同：#{} 预处理：而 ${} 是直接替换2、使用不同：#{} 适用于所有类型的参数匹配；但 ${} 只适用于数值类型。3、安全性不同：#{} 性能高，并且没有安全问题；但 $ {} 存在 SQL 注入的安全问题。4、使用场景不同：当传递的是一个 SQL 关键字 的时候，只能 使用 ${}。当传递的是一个字段，总之，就是需要获取到参数类型 与 内容，只能使用 #{}。（PS：数字类型，#{} 和 ${} 都是可以使用的！5、 ${} 不能用于 模糊匹配查询；
1112--接口
kequanrrr的博客
11-12 434
interface + 接口名{ }。。。。implements 接口名{ }接口：接口中的抽象方法可以省略 abstract 关键字使用：要实现接口中的所有 抽象方法隐含三个修饰符：public+static+final2.单继承 多接口。
SpringBoot 实现图片加水印
心猿意码
11-11 413
通过上述步骤，我们可以在SpringBoot项目中实现一个简单的图片加水印功能。当然，实际应用中可能需要更复杂的水印处理，比如水印图片、调整水印位置等，可以根据需求进行相应的扩展和优化。
刷题---顺序表算法题
weixin_63997543的博客
11-11 448
顺序算法题----力扣刷题
Java多线程与并发面试技巧：关键问题解析
多线程和并发编程的核心在于利用一个进程中的多个执行单元，提高程序性能并优化资源利用。 首先，理解进程与线程的区别至关重要。进程是独立的执行环境，每个进程有自己的地址空间，而线程则是进程内的执行单元，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值