一道很有意思的面试题目，快加入到这场头脑风暴游戏里吧~

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

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

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

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

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

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

正文

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，其他的阻塞队列也是可以的。

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

a.start();

b.start();

}

}

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



忙等待的方案很多，反正就是某个条件不满足时，不阻塞自己，阻塞了会释放 cpu，我们就是不希望释放 cpu 的。



比如像下面这样也可以：

public class Global1 {

public static volatile int var = 1;

public static final AtomicInteger atomicInteger =

new AtomicInteger(1);

public static void main(String[] args) {

Thread a = new Thread(() -> {

Global1.var++;

atomicInteger.set(2);

});

a.setName(“thread a”);

Thread b = new Thread(() -> {

while (true) {

boolean success = atomicInteger.compareAndSet(2, 1);

if (success) {

break;

} else {

Thread.yield();

}

}

if (Global1.var == 2) {

//do something;

System.out.println(Thread.currentThread().getName() + " good job");

}

});

b.setName(“thread b”);

a.start();

b.start();

}

}

# 总结：心得体会

既然选择这个行业，选择了做一个程序员，也就明白只有不断学习，积累实战经验才有资格往上走，拿高薪，为自己，为父母，为以后的家能有一定的经济保障。

学习时间都是自己挤出来的，短时间或许很难看到效果，一旦坚持下来了，必然会有所改变。不如好好想想自己为什么想进入这个行业，给自己内心一个答案。

面试大厂，最重要的就是夯实的基础，不然面试官随便一问你就凉了；其次会问一些技术原理，还会看你对知识掌握的广度，最重要的还是你的思路，这是面试官比较看重的。

最后，上面这些大厂面试真题都是非常好的学习资料，通过这些面试真题能够看看自己对技术知识掌握的大概情况，从而能够给自己定一个学习方向。包括上面分享到的学习指南，你都可以从学习指南里理顺学习路线，避免低效学习。

**大厂Java架构核心笔记（适合中高级程序员阅读）：**

![](https://img-blog.csdnimg.cn/img_convert/3b2672952f227096234ca3cef65ad917.webp?x-oss-process=image/format,png)



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

**需要这份系统化的资料的朋友，可以添加V获取：vip1024b （备注Java）**
![img](https://img-blog.csdnimg.cn/img_convert/ff1ab58b9c1e512671f90985c6fef51e.jpeg)

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

总结：心得体会

既然选择这个行业，选择了做一个程序员，也就明白只有不断学习，积累实战经验才有资格往上走，拿高薪，为自己，为父母，为以后的家能有一定的经济保障。

学习时间都是自己挤出来的，短时间或许很难看到效果，一旦坚持下来了，必然会有所改变。不如好好想想自己为什么想进入这个行业，给自己内心一个答案。

面试大厂，最重要的就是夯实的基础，不然面试官随便一问你就凉了；其次会问一些技术原理，还会看你对知识掌握的广度，最重要的还是你的思路，这是面试官比较看重的。

最后，上面这些大厂面试真题都是非常好的学习资料，通过这些面试真题能够看看自己对技术知识掌握的大概情况，从而能够给自己定一个学习方向。包括上面分享到的学习指南，你都可以从学习指南里理顺学习路线，避免低效学习。

大厂Java架构核心笔记（适合中高级程序员阅读）：

[外链图片转存中…(img-H6ArQOqF-1713293017891)]

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

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

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