线程间共享数据线程之间通讯

正常情况下，每个子线程都可以完成自己的任务。但是，有时候，我们希望多个线程协同工作来完成一项任务，这时就涉及到线程间的通信。本文涉及的知识点:螺纹。Join()，对象。Wait()，对

本文最后更新时间： 2023-03-26 11:30:25

正常情况下，每个子线程都可以完成自己的任务。但是，有时候，我们希望多个线程协同工作来完成一项任务，这时就涉及到线程间的通信。

本文涉及的知识点:螺纹。Join()，对象。Wait()，对象。Notify()，倒计时锁存，循环障碍，未来任务，可调用等。

从下面的例子为起点来解释Java中有哪些方法可以实现线程间的通信。

如何让两个线程依次执行？那如何让两个线程按照指定方式有序交叉运行呢？四个线程 A B C D，其中 D 要等到 A B C 全执行完毕后才执行，而且 A B C 是同步运行的三个运动员各自准备，等到三个人都准备好后，再一起跑子线程完成某件任务后，把得到的结果回传给主线程

如何让两个线程轮流执行？

假设有两个线程，一个是线程A，一个是线程B，两个线程依次打印1-3个数字。让我们看一下代码:

的printNumber(String)实现如下，用于依次打印1、2、3个数字:

这时，我们得到以下结果:

b打印:1

一个打印:1

b打印:2

一个打印:2

b印刷品:3

一个打印:3

你可以看到A和B是同时打印的。

那么，如果我们想让B在A打印完之后开始打印呢？我们可以通过以下代码利用thread.join()方法:

结果如下:

b开始等待a。

一个打印:1

一个打印:2

一个打印:3

b打印:1

b打印:2

b印刷品:3

所以我们可以看到A.join()方法会让B一直等到A运行。

那么如何让两个线程按照指定的方式交替运行呢？

还是上面那个例子。现在，我希望在A打印1之后，B打印1、2和3，然后我会回到A继续打印2和3。在这种需求下，显然已经不能满足Thread.join()了。我们需要更细粒度的锁来控制执行顺序。

这里可以用object.wait()和object.notify()来实现。代码如下:

打印结果如下:

A 1

一个等待…

B 1

B 2

B 3

A 2

A 3

这正是我们想要的。

那么，这个过程中发生了什么？

首先创建一个 A 和 B 共享的对象锁 lock = new Object();当 A 得到锁后，先打印 1，然后调用 lock.wait() 方法，交出锁的控制权，进入 wait 状态；对 B 而言，由于 A 最开始得到了锁，导致 B 无法执行；直到 A 调用 lock.wait() 释放控制权后， B 才得到了锁；B 在得到锁后打印 1， 2， 3；然后调用 lock.notify() 方法，唤醒正在 wait 的 A;A 被唤醒后，继续打印剩下的 2，3。

为了更好地理解，我在上面的代码中添加了log以供读者检查。

打印结果如下:

INFO: A 等待锁INFO: A 得到了锁 lockA 1INFO: A 准备进入等待状态，调用 lock.wait() 放弃锁 lock 的控制权INFO: B 等待锁INFO: B 得到了锁 lockB 1B 2B 3INFO: B 打印完毕，调用 lock.notify() 方法INFO: 有人唤醒了 A, A 重新获得锁 lockA 2A 3

有四个线程，A B C D，其中D直到A B C完全执行后才会执行，A B C同步运行。

起初，我们引入了thread.join()，它允许一个线程在继续执行之前等待另一个线程完成运行。然后，我们可以在D线程中依次加入一个B C，但这也使得一个B C必须依次执行，而我们想要的是三者可以同步运行。

或者说，我们希望实现的是:A B C三个线程同时运行，每个线程独立运行后通知D；就D而言，只要A B C跑完了，D就会重新开始跑。针对这种情况，我们可以使用CountdownLatch来实现这种通信。它的基本用法是:

创建一个计数器，设置初始值，CountdownLatch countDownLatch = new CountDownLatch(2);在等待线程里调用 countDownLatch.await() 方法，进入等待状态，直到计数值变成 0；在其他线程里，调用 countDownLatch.countDown() 方法，该方法会将计数值减小 1；当其他线程的 countDown() 方法把计数值变成 0 时，等待线程里的 countDownLatch.await() 立即退出，继续执行下面的代码。

实现代码如下:

以下是运行结果:

d正在等待其他三个线程

a正在工作

b在工作

c正在工作

a完成

c完成

b完成

一切完成后，D开始工作

其实简单来说，CountDownLatch就是一个倒计数。我们将初始计数值设置为3。D运行时，先调用countDownLatch.await()检查计数器值是否为0，如果不是，继续等待；A B C会使用countDownLatch.countDown()在每次操作后将递减计数器减1。当所有三个操作都完成时，计数器将减少到0；此时会立即触发D的await()操作，继续向下执行。

因此，CountDownLatch适用于一个线程等待多个线程。

三个运动员互相准备，三个都准备好了，就一起跑。

以上是形象比喻。每个线程A B C开始准备，直到三个都准备好了，然后同时运行。也就是要达到线程互相等待的效果，应该如何实现？

上面的CountDownLatch可以用来倒计数，但是计数完了，只有一个线程的await()会得到响应，不能同时触发多个线程。

为了满足线程间相互等待的需求，可以利用循环屏障数据结构。它的基本用法是:

先创建一个公共 CyclicBarrier 对象，设置同时等待的线程数，CyclicBarrier cyclicBarrier = new CyclicBarrier(3);这些线程同时开始自己做准备，自身准备完毕后，需要等待别人准备完毕，这时调用 cyclicBarrier.await(); 即可开始等待别人；当指定的同时等待的线程数都调用了 cyclicBarrier.await();时，意味着这些线程都准备完毕好，然后这些线程才同时继续执行。

实现代码如下。假设有三个跑步者，每个人都准备好等待其他人，并且在开始跑步之前都准备好了:

打印结果如下:

A is preparing for time: 4131B is preparing for time: 6349C is preparing for time: 8206A is prepared, waiting for othersB is prepared, waiting for othersC is prepared, waiting for othersC starts runningA starts runningB starts running

当子线程完成一项任务时，它会将结果发送回主线程。

在Java的实际开发中，我们经常会创建子线程来做一些耗时的任务，然后将任务执行的结果发回给主线程使用。这种情况如何在Java中实现？

回头看看线程的创建，我们通常将Runnable对象传递给线程执行。可运行的定义如下:

可以看到run()在执行后没有返回任何结果。如果你想返回结果呢？在这里，您可以使用另一个类似的接口类Callable:

可以看出Callable最大的不同在于它返回的是规范的V结果。

那么接下来的问题就是，如何将子线程的结果发回？在Java中，有一个与Callable一起使用的类:FutureTask，但是注意它获取结果的get方法会阻塞主线程。

例如，我们希望子线程将1加到100，并将计算结果返回给主线程。

打印结果如下:

在futureTask.get()之前

任务开始

任务完成并返回结果

结果:5050