面试官：线程顺序执行,这么多答案你都答不上来？，分布式缓存面试题

先自我介绍一下，小编浙江大学毕业，去过华为、字节跳动等大厂，目前阿里P7

深知大多数程序员，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年最新Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，涵盖了95%以上Java开发知识点，真正体系化！

由于文件比较多，这里只是将部分目录截图出来，全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频，并且后续会持续更新

如果你需要这些资料，可以添加V获取：vip1024b （备注Java）

正文

wait(long timeout):让当前线程处于“等待(阻塞)状态”，“直到其他线程调用此对象的notify()方法或 notifyAll() 方法，或者超过指定的时间量”，当前线程被唤醒(进入“就绪状态”)。

应用场景：Java实现生产者消费者的方式。

package com.wwj.javabase.thread.order;

/**

* @author wwj

*/

public class ThreadWaitDemo {

private static Object myLock1 = new Object();

private static Object myLock2 = new Object();

/**

* 为什么要加这两个标识状态?

* 如果没有状态标识，当t1已经运行完了t2才运行，t2在等待t1唤醒导致t2永远处于等待状态

*/

private static Boolean t1Run = false;

private static Boolean t2Run = false;

public static void main(String[] args) {

final Thread thread1 = new Thread(new Runnable() {

@Override

public void run() {

synchronized (myLock1){

System.out.println(“产品经理规划新需求…”);

t1Run = true;

myLock1.notify();

}

}

});

final Thread thread2 = new Thread(new Runnable() {

@Override

public void run() {

synchronized (myLock1){

try {

if(!t1Run){

System.out.println(“开发人员先休息会…”);

myLock1.wait();

}

synchronized (myLock2){

System.out.println(“开发人员开发新需求功能”);

myLock2.notify();

}

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

});

Thread thread3 = new Thread(new Runnable() {

@Override

public void run() {

synchronized (myLock2){

try {

if(!t2Run){

System.out.println(“测试人员先休息会…”);

myLock2.wait();

}

System.out.println(“测试人员测试新功能”);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

}

});

System.out.println(“早上：”);

System.out.println(“测试人员来上班了…”);

thread3.start();

System.out.println(“产品经理来上班了…”);

thread1.start();

System.out.println(“开发人员来上班了…”);

thread2.start();

}

}

运行结果:这里输出会有很多种顺序，主要是因为线程进入的顺序，造成锁住线程的顺序不一致。

早上：

测试人员来上班了…

产品经理来上班了…

开发人员来上班了…

测试人员先休息会…

产品经理规划新需求…

开发人员开发新需求功能

测试人员测试新功能

4.使用线程的线程池方法

JAVA通过Executors提供了四种线程池

• 单线程化线程池(newSingleThreadExecutor);

• 可控最大并发数线程池(newFixedThreadPool);

• 可回收缓存线程池(newCachedThreadPool);

• 支持定时与周期性任务的线程池(newScheduledThreadPool)。

单线程化线程池(newSingleThreadExecutor):优点，串行执行所有任务。

submit()：提交任务。

shutdown()：方法用来关闭线程池，拒绝新任务。

应用场景:串行执行所有任务。如果这个唯一的线程因为异常结束，那么会有一个新的线程来替代它。此线程池保证所有任务的执行顺序按照任务的提交顺序执行。

package com.wwj.javabase.thread.order;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

/**

* @author wwj

* 通过SingleThreadExecutor让线程按顺序执行

*/

public class ThreadPoolDemo {

static ExecutorService executorService = Executors.newSingleThreadExecutor();

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

final Thread thread1 = new Thread(new Runnable() {

@Override

public void run() {

System.out.println(“产品经理规划新需求”);

}

});

final Thread thread2 = new Thread(new Runnable() {

@Override

public void run() {

System.out.println(“开发人员开发新需求功能”);

}

});

Thread thread3 = new Thread(new Runnable() {

@Override

public void run() {

System.out.println(“测试人员测试新功能”);

}

});

System.out.println(“早上：”);

System.out.println(“产品经理来上班了”);

System.out.println(“测试人员来上班了”);

System.out.println(“开发人员来上班了”);

System.out.println(“领导吩咐:”);

System.out.println(“首先，产品经理规划新需求…”);

executorService.submit(thread1);

System.out.println(“然后，开发人员开发新需求功能…”);

executorService.submit(thread2);

System.out.println(“最后，测试人员测试新功能…”);

executorService.submit(thread3);

executorService.shutdown();

}

}

运行结果

早上：

产品经理来上班了

测试人员来上班了

开发人员来上班了

领导吩咐:

首先，产品经理规划新需求…

然后，开发人员开发新需求功能…

最后，测试人员测试新功能…

产品经理规划新需求

开发人员开发新需求功能

测试人员测试新功能

5.使用线程的Condition(条件变量)方法

Condition（条件变量）:通常与一个锁关联。需要在多个Contidion中共享一个锁时，可以传递一个Lock/RLock实例给构造方法，否则它将自己生成一个RLock实例。

• Condition中**await()**方法类似于Object类中的wait()方法。

• Condition中**await(long time,TimeUnit unit)**方法类似于Object类中的wait(long time)方法。

• Condition中**signal()**方法类似于Object类中的notify()方法。

• Condition中**signalAll()**方法类似于Object类中的notifyAll()方法。

应用场景：Condition是一个多线程间协调通信的工具类，使得某个，或者某些线程一起等待某个条件（Condition）,只有当该条件具备( signal 或者 signalAll方法被带调用)时 ，这些等待线程才会被唤醒，从而重新争夺锁。

package com.wwj.javabase.thread.order;

import java.util.concurrent.locks.Condition;

import java.util.concurrent.locks.Lock;

import java.util.concurrent.locks.ReentrantLock;

/**

* @author wwj

* 使用Condition(条件变量)实现线程按顺序运行

*/

public class ThreadConditionDemo {

private static Lock lock = new ReentrantLock();

private static Condition condition1 = lock.newCondition();

private static Condition condition2 = lock.newCondition();

/**

* 为什么要加这两个标识状态?

* 如果没有状态标识，当t1已经运行完了t2才运行，t2在等待t1唤醒导致t2永远处于等待状态

*/

private static Boolean t1Run = false;

private static Boolean t2Run = false;

public static void main(String[] args) {

final Thread thread1 = new Thread(new Runnable() {

@Override

public void run() {

lock.lock();

System.out.println(“产品经理规划新需求”);

t1Run = true;

condition1.signal();

lock.unlock();

}

});

final Thread thread2 = new Thread(new Runnable() {

@Override

public void run() {

lock.lock();

try {

if(!t1Run){

System.out.println(“开发人员先休息会…”);

condition1.await();

}

System.out.println(“开发人员开发新需求功能”);

t2Run = true;

condition2.signal();

} catch (InterruptedException e) {

e.printStackTrace();

}

lock.unlock();

}

});

Thread thread3 = new Thread(new Runnable() {

@Override

public void run() {

lock.lock();

try {

if(!t2Run){

System.out.println(“测试人员先休息会…”);

condition2.await();

}

System.out.println(“测试人员测试新功能”);

lock.unlock();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

});

System.out.println(“早上：”);

System.out.println(“测试人员来上班了…”);

thread3.start();

System.out.println(“产品经理来上班了…”);

thread1.start();

System.out.println(“开发人员来上班了…”);

thread2.start();

}

}

运行结果:这里输出会有很多种顺序，主要是因为线程进入的顺序，造成锁住线程的顺序不一致

早上：

测试人员来上班了…

产品经理来上班了…

开发人员来上班了…

测试人员先休息会…

产品经理规划新需求

开发人员开发新需求功能

测试人员测试新功能

6.使用线程的CountDownLatch（倒计数）方法

CountDownLatch:位于java.util.concurrent包下，利用它可以实现类似计数器的功能。

应用场景:比如有一个任务C，它要等待其他任务A,B执行完毕之后才能执行，此时就可以利用CountDownLatch来实现这种功能了。

package com.wwj.javabase.thread.order;

import java.util.concurrent.CountDownLatch;

/**

* @author wwj

* 通过CountDownLatch（倒计数）使线程按顺序执行

*/

public class ThreadCountDownLatchDemo {

/**

* 用于判断线程一是否执行，倒计时设置为1，执行后减1

*/

private static CountDownLatch c1 = new CountDownLatch(1);

/**

* 用于判断线程二是否执行，倒计时设置为1，执行后减1

*/

private static CountDownLatch c2 = new CountDownLatch(1);

public static void main(String[] args) {

final Thread thread1 = new Thread(new Runnable() {

@Override

public void run() {

System.out.println(“产品经理规划新需求”);

//对c1倒计时-1

c1.countDown();

}

});

final Thread thread2 = new Thread(new Runnable() {

@Override

public void run() {

try {

//等待c1倒计时，计时为0则往下运行

c1.await();

System.out.println(“开发人员开发新需求功能”);

//对c2倒计时-1

c2.countDown();

} catch (InterruptedException e) {

e.printStackTrace();

}

}

});

Thread thread3 = new Thread(new Runnable() {

@Override

public void run() {

try {

//等待c2倒计时，计时为0则往下运行

c2.await();

System.out.println(“测试人员测试新功能”);

} catch (InterruptedException e) {

e.printStackTrace();

}

}

});

System.out.println(“早上：”);

System.out.println(“测试人员来上班了…”);

thread3.start();

System.out.println(“产品经理来上班了…”);

thread1.start();

System.out.println(“开发人员来上班了…”);

thread2.start();

}

}

运行结果

早上：

测试人员来上班了…

产品经理来上班了…

开发人员来上班了…

产品经理规划新需求

开发人员开发新需求功能

测试人员测试新功能

7.使用CyclicBarrier(回环栅栏)实现线程按顺序运行

CyclicBarrier(回环栅栏):通过它可以实现让一组线程等待至某个状态之后再全部同时执行。叫做回环是因为当所有等待线程都被释放以后，CyclicBarrier可以被重用。我们暂且把这个状态就叫做barrier，当调用await()方法之后，线程就处于barrier了。

应用场景:公司组织春游,等待所有的员工到达集合地点才能出发，每个人到达后进入barrier状态。都到达后，唤起大家一起出发去旅行。

package com.wwj.javabase.thread.order;

import java.util.concurrent.BrokenBarrierException;

import java.util.concurrent.CyclicBarrier;

/**

* @author wwj

* 使用CyclicBarrier(回环栅栏)实现线程按顺序运行

*/

public class CyclicBarrierDemo {

static CyclicBarrier barrier1 = new CyclicBarrier(2);

static CyclicBarrier barrier2 = new CyclicBarrier(2);

public static void main(String[] args) {

final Thread thread1 = new Thread(new Runnable() {

@Override

public void run() {

try {

System.out.println(“产品经理规划新需求”);

//放开栅栏1

barrier1.await();

} catch (InterruptedException e) {

e.printStackTrace();

} catch (BrokenBarrierException e) {

e.printStackTrace();

}

}

});

final Thread thread2 = new Thread(new Runnable() {

@Override

public void run() {

try {

//放开栅栏1

barrier1.await();

System.out.println(“开发人员开发新需求功能”);

//放开栅栏2

barrier2.await();

} catch (InterruptedException e) {

e.printStackTrace();

} catch (BrokenBarrierException e) {

e.printStackTrace();

}

}

});

final Thread thread3 = new Thread(new Runnable() {

@Override

public void run() {

try {

//放开栅栏2

barrier2.await();

System.out.println(“测试人员测试新功能”);

} catch (InterruptedException e) {

e.printStackTrace();

} catch (BrokenBarrierException e) {

e.printStackTrace();

最后

整理的这些资料希望对Java开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。

其实面试这一块早在第一个说的25大面试专题就全都有的。以上提及的这些全部的面试+学习的各种笔记资料，我这差不多来回搞了三个多月，收集整理真的很不容易，其中还有很多自己的一些知识总结。正是因为很麻烦，所以对以上这些学习复习资料感兴趣

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！
tion e) {

e.printStackTrace();

} catch (BrokenBarrierException e) {

e.printStackTrace();

}

}

});

final Thread thread3 = new Thread(new Runnable() {

@Override

public void run() {

try {

//放开栅栏2

barrier2.await();

System.out.println(“测试人员测试新功能”);

} catch (InterruptedException e) {

e.printStackTrace();

} catch (BrokenBarrierException e) {

e.printStackTrace();

最后

整理的这些资料希望对Java开发的朋友们有所参考以及少走弯路，本文的重点是你有没有收获与成长，其余的都不重要，希望读者们能谨记这一点。

[外链图片转存中…(img-AzCeBoq2-1713386916765)]

[外链图片转存中…(img-ynT3xFt7-1713386916766)]

其实面试这一块早在第一个说的25大面试专题就全都有的。以上提及的这些全部的面试+学习的各种笔记资料，我这差不多来回搞了三个多月，收集整理真的很不容易，其中还有很多自己的一些知识总结。正是因为很麻烦，所以对以上这些学习复习资料感兴趣

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）
[外链图片转存中…(img-tpg4Qnkq-1713386916766)]

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！