如何在Java中实现线程间通信

最新推荐文章于 2023-02-11 12:54:23 发布
最新推荐文章于 2023-02-11 12:54:23 发布
阅读量366 收藏 1
点赞数 1
文章标签： java 多线程
本文深入探讨Java中线程间通信的多种方式，包括使用join(), wait(), notify(), CountdownLatch, CyclicBarrier等方法实现线程的同步执行和结果传递。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

虽然通常每个子线程只需要完成自己的任务，但有时我们可能希望多个线程一起工作来完成一个任务，这涉及到线程间的通信。

本文中涉及的方法和类是：thread.join()，object.wait()，object.notify()，CountdownLatch，CyclicBarrier，FutureTask，Callable，等。

以下是本文中介绍的代码

我将使用几个示例来解释如何在Java中实现线程间通信。

  • 如何使两个线程按顺序执行？
  • 如何使两个线程以指定的方式有序交叉？
  • 有四个线程：A，B，C和D（直到A，B和C都执行完毕才会执行D，并且A，B和C将同步执行。）。
  • 三名运动员分开准备，然后他们在每个运动员准备好后同时开始跑步。
  • 子线程完成任务后，它会将结果返回给主线程。

如何使两个线程按顺序执行？

假设有两个线程：线程A和线程B.两个线程都可以按顺序打印三个数字（1-3）。我们来看看代码：

<span style="color:#333333"><code class="language-java"><span style="color:#333333"><strong>private</strong></span> <span style="color:#333333"><strong>static</strong></span> <span style="color:#333333"><strong>void</strong></span> <span style="color:#990000"><strong>demo1</strong></span>() {
    Thread A = <span style="color:#333333"><strong>new</strong></span> Thread(<span style="color:#333333"><strong>new</strong></span> Runnable() {
        <span style="color:#999999"><strong>@Override</strong></span>
        <span style="color:#333333"><strong>public</strong></span> <span style="color:#333333"><strong>void</strong></span> <span style="color:#990000"><strong>run</strong></span>() {
            printNumber(<span style="color:#dd1144">"A"</span>);
        }
    });
    Thread B = <span style="color:#333333"><strong>new</strong></span> Thread(<span style="color:#333333"><strong>new</strong></span> Runnable() {
        <span style="color:#999999"><strong>@Override</strong></span>
        <span style="color:#333333"><strong>public</strong></span> <span style="color:#333333"><strong>void</strong></span> <span style="color:#990000"><strong>run</strong></span>() {
            printNumber(<span style="color:#dd1144">"B"</span>);
        }
    });
    A.start();
    B.start();
}</code></span>

实现printNumber(String)如下，用于依次打印1,2和3三个数字：

<span style="color:#333333"><code class="language-java"><span style="color:#333333"><strong>private</strong></span> <span style="color:#333333"><strong>static</strong></span> <span style="color:#333333"><strong>void</strong></span> <span style="color:#990000"><strong>printNumber</strong></span>(String threadName) {
    <span style="color:#333333"><strong>int</strong></span> i=<span style="color:#008080">0</span>;
    <span style="color:#333333"><strong>while</strong></span> (i++ < <span style="color:#008080">3</span>) {
        <span style="color:#333333"><strong>try</strong></span> {
            Thread.sleep(<span style="color:#008080">100</span>);
        } <span style="color:#333333"><strong>catch</strong></span> (InterruptedException e) {
            e.printStackTrace();
        }
        System.<span style="color:#333333"><strong>out</strong></span>.println(threadName + <span style="color:#dd1144">"print:"</span> + i);
    }
}</code></span>

我们得到的结果是：

<span style="color:#333333"><code class="language-bash"><span style="color:#445588"><strong>B</strong></span> <span style="color:#0086b3">print</span>: <span style="color:#008080">1</span>
<span style="color:#445588"><strong>A</strong></span> <span style="color:#0086b3">print</span>: <span style="color:#008080">1</span>
<span style="color:#445588"><strong>B</strong></span> <span style="color:#0086b3">print</span>: <span style="color:#008080">2</span>
<span style="color:#445588"><strong>A</strong></span> <span style="color:#0086b3">print</span>: <span style="color:#008080">2</span>
<span style="color:#445588"><strong>B</strong></span> <span style="color:#0086b3">print</span>: <span style="color:#008080">3</span>
<span style="color:#445588"><strong>A</strong></span> <span style="color:#0086b3">print</span>: <span style="color:#008080">3</span></code></span>

您可以同时看到A和B打印数字。

那么，如果我们希望B在A打印完毕后开始打印怎么办？我们可以使用该thread.join()方法，代码如下：

<span style="color:#333333"><code class="language-java"><span style="color:#333333"><strong>private</strong></span> <span style="color:#333333"><strong>static</strong></span> <span style="color:#333333"><strong>void</strong></span> <span style="color:#990000"><strong>demo2</strong></span>() {
    Thread A = <span style="color:#333333"><strong>new</strong></span> Thread(<span style="color:#333333"><strong>new</strong></span> Runnable() {
        <span style="color:#999999"><strong>@Override</strong></span>
        <span style="color:#333333"><strong>public</strong></span> <span style="color:#333333"><strong>void</strong></span> <span style="color:#990000"><strong>run</strong></span>() {
            printNumber(<span style="color:#dd1144">"A"</span>);
        }
    });
    Thread B = <span style="color:#333333"><strong>new</strong></span> Thread(<span style="color:#333333"><strong>new</strong></span> Runnable() {
        <span style="color:#999999"><strong>@Override</strong></span>
        <span style="color:#333333"><strong>public</strong></span> <span style="color:#333333"><strong>void</strong></span> <span style="color:#990000"><strong>run</strong></span>() {
            System.out.println(<span style="color:#dd1144">"B starts waiting for A"</span>);
            <span style="color:#333333"><strong>try</strong></span> {
                A.join();
            } <span style="color:#333333"><strong>catch</strong></span> (InterruptedException e) {
                e.printStackTrace();
            }
            printNumber(<span style="color:#dd1144">"B"</span>);
        }
    });
    B.start();
    A.start();
}</code></span>

现在得到的结果是：

<span style="color:#333333"><code class="language-bash"><span style="color:#445588"><strong>B</strong></span> starts waiting <span style="color:#333333"><strong>for</strong></span> <span style="color:#445588"><strong>A</strong></span>
<span style="color:#445588"><strong>A</strong></span> <span style="color:#0086b3">print</span>: <span style="color:#008080">1</span>
<span style="color:#445588"><strong>A</strong></span> <span style="color:#0086b3">print</span>: <span style="color:#008080">2</span>
<span style="color:#445588"><strong>A</strong></span> <span style="color:#0086b3">print</span>: <span style="color:#008080">3</span>
 
<span style="color:#445588"><strong>B</strong></span> <span style="color:#0086b3">print</span>: <span style="color:#008080">1</span>
<span style="color:#445588"><strong>B</strong></span> <span style="color:#0086b3">print</span>: <span style="color:#008080">2</span>
<span style="color:#445588"><strong>B</strong></span> <span style="color:#0086b3">print</span>: <span style="color:#008080">3</span></code></span>

所以我们可以看到该A.join()方法将使B等到A完成打印。

如何以指定的方式有序地使两个线程交叉？

那么如果现在我们希望B在A打印1之后开始打印1,2,3，那么A继续打印2,3？显然，我们需要更细粒度的锁来控制执行顺序。

在这里，我们可以利用object.wait()和object.notify()方法的优势。代码如下：

<span style="color:#333333"><code class="language-java"><span style="color:#999988">/**
 * A 1, B 1, B 2, B 3, A 2, A 3
 */</span>
<span style="color:#333333"><strong>private</strong></span> <span style="color:#333333"><strong>static</strong></span> <span style="color:#333333"><strong>void</strong></span> <span style="color:#990000"><strong>demo3</strong></span>() {
    Object <span style="color:#333333"><strong>lock</strong></span> = <span style="color:#333333"><strong>new</strong></span> Object();
    Thread A = <span style="color:#333333"><strong>new</strong></span> Thread(<span style="color:#333333"><strong>new</strong></span> Runnable() {
        @Override
        <span style="color:#333333"><strong>public</strong></span> <span style="color:#333333"><strong>void</strong></span> <span style="color:#990000"><strong>run</strong></span>() {
            synchronized (<span style="color:#333333"><strong>lock</strong></span>) {
                System.<span style="color:#333333"><strong>out</strong></span>.println(<span style="color:#dd1144">"A 1"</span>);
                <span style="color:#333333"><strong>try</strong></span> {
                    <span style="color:#333333"><strong>lock</strong></span>.wait();
                } <span style="color:#333333"><strong>catch</strong></span> (InterruptedException e) {
                    e.printStackTrace();
                }
                System.<span style="color:#333333"><strong>out</strong></span>.println(<span style="color:#dd1144">"A 2"</span>);
                System.<span style="color:#333333"><strong>out</strong></span>.println(<span style="color:#dd1144">"A 3"</span>);
            }
        }
    });
    Thread B = <span style="color:#333333"><strong>new</strong></span> Thread(<span style="color:#333333"><strong>new</strong></span> Runnable() {
        @Override
        <span style="color:#333333"><strong>public</strong></span> <span style="color:#333333"><strong>void</strong></span> <span style="color:#990000"><strong>run</strong></span>() {
            synchronized (<span style="color:#333333"><strong>lock</strong></span>) {
                System.<span style="color:#333333"><strong>out</strong></span>.println(<span style="color:#dd1144">"B 1"</span>);
                System.<span style="color:#333333"><strong>out</strong></span>.println(<span style="color:#dd1144">"B 2"</span>);
                System.<span style="color:#333333"><strong>out</strong></span>.println(<span style="color:#dd1144">"B 3"</span>);
                <span style="color:#333333"><strong>lock</strong></span>.notify();
            }
        }
    });
    A.start();
    B.start();
}</code></span>

结果如下：

<span style="color:#333333"><code class="language-bash"><span style="color:#000080">A</span> <span style="color:#008080">1</span>
A waiting…
 
B <span style="color:#008080">1</span>
B <span style="color:#008080">2</span>
B <span style="color:#008080">3</span>
A <span style="color:#008080">2</span>
A <span style="color:#008080">3</span></code></span>

这就是我们想要的。

怎么了？

  1. 首先，我们创建一个由A和B共享的对象锁： lock = new Object();
  2. 当A获得锁定时，它首先打印1，然后调用lock.wait()方法使其进入等待状态，然后移交锁定控制;
  3. 在A调用lock.wait()释放控制的方法并且B获得锁定之前，B不会被执行;
  4. B在获得锁定后打印1,2,3，然后调用lock.notify()方法唤醒正在等待的A;
  5. A唤醒后继续打印剩余的2,3。

我将日志添加到上面的代码中，以便更容易理解。

<span style="color:#333333"><code class="language-java"><span style="color:#333333"><strong>private</strong></span> <span style="color:#333333"><strong>static</strong></span> <span style="color:#333333"><strong>void</strong></span> <span style="color:#990000"><strong>demo3</strong></span>() {
    Object <span style="color:#333333"><strong>lock</strong></span> = <span style="color:#333333"><strong>new</strong></span> Object();
    Thread A = <span style="color:#333333"><strong>new</strong></span> Thread(<span style="color:#333333"><strong>new</strong></span> Runnable() {
        @Override
        <span style="color:#333333"><strong>public</strong></span> <span style="color:#333333"><strong>void</strong></span> <span style="color:#990000"><strong>run</strong></span>() {
            System.<span style="color:#333333"><strong>out</strong></span>.println(<span style="color:#dd1144">"INFO: A is waiting for the lock"</span>);
            synchronized (<span style="color:#333333"><strong>lock</strong></span>) {
                System.<span style="color:#333333"><strong>out</strong></span>.println(<span style="color:#dd1144">"INFO: A got the lock"</span>);
                System.<span style="color:#333333"><strong>out</strong></span>.println(<span style="color:#dd1144">"A 1"</span>);
                <span style="color:#333333"><strong>try</strong></span> {
                    System.<span style="color:#333333"><strong>out</strong></span>.println(<span style="color:#dd1144">"INFO: A is ready to enter the wait state, giving up control of the lock"</span>);
                    <span style="color:#333333"><strong>lock</strong></span>.wait();
                } <span style="color:#333333"><strong>catch</strong></span> (InterruptedException e) {
                    e.printStackTrace();
                }
                System.<span style="color:#333333"><strong>out</strong></span>.println(<span style="color:#dd1144">"INFO: B wakes up A, and A regains the lock"</span>);
                System.<span style="color:#333333"><strong>out</strong></span>.println(<span style="color:#dd1144">"A 2"</span>);
                System.<span style="color:#333333"><strong>out</strong></span>.println(<span style="color:#dd1144">"A 3"</span>);
            }
        }
    });
    Thread B = <span style="color:#333333"><strong>new</strong></span> Thread(<span style="color:#333333"><strong>new</strong></span> Runnable() {
        @Override
        <span style="color:#333333"><strong>public</strong></span> <span style="color:#333333"><strong>void</strong></span> <span style="color:#990000"><strong>run</strong></span>() {
            System.<span style="color:#333333"><strong>out</strong></span>.println(<span style="color:#dd1144">"INFO: B is waiting for the lock"</span>);
            synchronized (<span style="color:#333333"><strong>lock</strong></span>) {
                System.<span style="color:#333333"><strong>out</strong></span>.println(<span style="color:#dd1144">"INFO: B got the lock"</span>);
                System.<span style="color:#333333"><strong>out</strong></span>.println(<span style="color:#dd1144">"B 1"</span>);
                System.<span style="color:#333333"><strong>out</strong></span>.println(<span style="color:#dd1144">"B 2"</span>);
                System.<span style="color:#333333"><strong>out</strong></span>.println(<span style="color:#dd1144">"B 3"</span>);
                System.<span style="color:#333333"><strong>out</strong></span>.println(<span style="color:#dd1144">"INFO: B ends printing, and calling the notify method"</span>);
                <span style="color:#333333"><strong>lock</strong></span>.notify();
            }
        }
    });
    A.start();
    B.start();</code></span>

结果如下：

<span style="color:#333333"><code class="language-bash">INFO: A is waiting for the <span style="color:#333333"><strong>lock</strong></span>
INFO: A got the <span style="color:#333333"><strong>lock</strong></span>
A <span style="color:#008080">1</span>
INFO: A <span style="color:#333333"><strong>is</strong></span> ready <span style="color:#333333"><strong>to</strong></span> enter the <span style="color:#333333"><strong>wait</strong></span> state, giving up control <span style="color:#333333"><strong>of</strong></span> the <span style="color:#333333"><strong>lock</strong></span>
INFO: B <span style="color:#333333"><strong>is</strong></span> waiting <span style="color:#333333"><strong>for</strong></span> the <span style="color:#333333"><strong>lock</strong></span>
INFO: B got the <span style="color:#333333"><strong>lock</strong></span>
B <span style="color:#008080">1</span>
B <span style="color:#008080">2</span>
B <span style="color:#008080">3</span>
INFO: B ends printing, <span style="color:#333333"><strong>and</strong></span> <span style="color:#333333"><strong>calling</strong></span> the notify method
INFO: B wakes up A, <span style="color:#333333"><strong>and</strong></span> A regains the <span style="color:#333333"><strong>lock</strong></span>
A <span style="color:#008080">2</span>
A <span style="color:#008080">3</span></code></span>

D，A，B和C之后执行所有已完成同步执行

thread.join()前面介绍的方法允许一个线程在等待另一个线程完成运行后继续执行。但是如果我们将A，B和C有序地连接到D线程中，它将依次执行A，B和C，而我们希望它们三个同步运行。

我们要实现的目标是：三个线程A，B和C可以同时开始运行，每个线程在完成独立运行后都会通知D; 在A，B和C全部完成运行之前，D不会开始运行。所以我们CountdownLatch用来实现这种类型的通信。它的基本用法是：

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

实现代码如下：

<span style="color:#333333"><code class="language-java"><span style="color:#333333"><strong>private</strong></span> <span style="color:#333333"><strong>static</strong></span> <span style="color:#333333"><strong>void</strong></span> <span style="color:#990000"><strong>runDAfterABC</strong></span>() {
    <span style="color:#333333"><strong>int</strong></span> worker = <span style="color:#008080">3</span>;
    CountDownLatch countDownLatch = <span style="color:#333333"><strong>new</strong></span> CountDownLatch(worker);
    <span style="color:#333333"><strong>new</strong></span> Thread(<span style="color:#333333"><strong>new</strong></span> Runnable() {
        @Override
        <span style="color:#333333"><strong>public</strong></span> <span style="color:#333333"><strong>void</strong></span> <span style="color:#990000"><strong>run</strong></span>() {
            System.<span style="color:#333333"><strong>out</strong></span>.println(<span style="color:#dd1144">"D is waiting for other three threads"</span>);
            <span style="color:#333333"><strong>try</strong></span> {
                countDownLatch.await();
                System.<span style="color:#333333"><strong>out</strong></span>.println(<span style="color:#dd1144">"All done, D starts working"</span>);
            } <span style="color:#333333"><strong>catch</strong></span> (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }).start();
    <span style="color:#333333"><strong>for</strong></span> (<span style="color:#333333"><strong>char</strong></span> threadName=<span style="color:#dd1144">'A'</span>; threadName <= <span style="color:#dd1144">'C'</span>; threadName++) {
        final String tN = String.valueOf(threadName);
        <span style="color:#333333"><strong>new</strong></span> Thread(<span style="color:#333333"><strong>new</strong></span> Runnable() {
            @Override
            <span style="color:#333333"><strong>public</strong></span> <span style="color:#333333"><strong>void</strong></span> <span style="color:#990000"><strong>run</strong></span>() {
                System.<span style="color:#333333"><strong>out</strong></span>.println(tN + <span style="color:#dd1144">"is working"</span>);
                <span style="color:#333333"><strong>try</strong></span> {
                    Thread.sleep(<span style="color:#008080">100</span>);
                } <span style="color:#333333"><strong>catch</strong></span> (Exception e) {
                    e.printStackTrace();
                }
                System.<span style="color:#333333"><strong>out</strong></span>.println(tN + <span style="color:#dd1144">"finished"</span>);
                countDownLatch.countDown();
            }
        }).start();
    }
}</code></span>

结果如下：

<span style="color:#333333"><code class="language-bash"><span style="color:#445588"><strong>D</strong></span> <span style="color:#333333"><strong>is</strong></span> waiting <span style="color:#333333"><strong>for</strong></span> other three threads
<span style="color:#445588"><strong>A</strong></span> <span style="color:#333333"><strong>is</strong></span> working
<span style="color:#445588"><strong>B</strong></span> <span style="color:#333333"><strong>is</strong></span> working
<span style="color:#445588"><strong>C</strong></span> <span style="color:#333333"><strong>is</strong></span> working
 
<span style="color:#445588"><strong>A</strong></span> finished
<span style="color:#445588"><strong>C</strong></span> finished
<span style="color:#445588"><strong>B</strong></span> finished
<span style="color:#445588"><strong>All</strong></span> done, <span style="color:#445588"><strong>D</strong></span> starts working</code></span>

实际上，CountDownLatch它本身就是倒计时器，我们将初始计数值设置为3.当D运行时，它首先调用countDownLatch.await()方法来检查计数器值是否为0，如果值不为0，它将保持等待状态A，B和C各自将使用该countDownLatch.countDown()方法在单独完成运行后将倒数计数器递减1。当所有这三个完成运行时，计数器将减少到0; 然后，await()D 的方法将被触发结束A，B和C，D将开始继续执行。

因此，CountDownLatch适用于一个线程需要等待多个线程的情况。

3名跑步者准备跑步

三个跑步者准备分开，然后他们在每个准备好之后开始同时跑步。

这次，三个线程A，B和C中的每一个都需要单独准备，然后它们在三个线程都准备就绪后开始同时运行。我们该如何实现这一目标？

在CountDownLatch上面可以用倒计时，但在完成计数的时候，只有一个线程的一个await()方法会得到响应，所以多线程不能在同一时间被触发。

为了实现线程相互等待的效果，我们可以使用CyclicBarrier数据结构，其基本用法是：

  1. 首先创建一个公共对象CyclicBarrier，并设置同时等待的线程数，CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
  2. 这些线程开始同时准备。准备好之后，他们需要等待其他人完成准备，所以要求cyclicBarrier.await()方法等待其他人;
  3. 当需要等待的指定线程全部调用该cyclicBarrier.await()方法时，这意味着这些线程已准备就绪，那么这些线程将开始同时继续执行。

实现代码如下。想象一下，有三个跑步者需要同时开始跑，所以他们需要等待其他人，直到他们都准备好了。

<span style="color:#333333"><code class="language-java"><span style="color:#333333"><strong>private</strong></span> <span style="color:#333333"><strong>static</strong></span> <span style="color:#333333"><strong>void</strong></span> <span style="color:#990000"><strong>runABCWhenAllReady</strong></span>() {
    <span style="color:#333333"><strong>int</strong></span> runner = <span style="color:#008080">3</span>;
    CyclicBarrier cyclicBarrier = <span style="color:#333333"><strong>new</strong></span> CyclicBarrier(runner);
    <span style="color:#333333"><strong>final</strong></span> Random random = <span style="color:#333333"><strong>new</strong></span> Random();
    <span style="color:#333333"><strong>for</strong></span> (<span style="color:#333333"><strong>char</strong></span> runnerName=<span style="color:#dd1144">'A'</span>; runnerName <= <span style="color:#dd1144">'C'</span>; runnerName++) {
        <span style="color:#333333"><strong>final</strong></span> String rN = String.valueOf(runnerName);
        <span style="color:#333333"><strong>new</strong></span> Thread(<span style="color:#333333"><strong>new</strong></span> Runnable() {
            <span style="color:#999999"><strong>@Override</strong></span>
            <span style="color:#333333"><strong>public</strong></span> <span style="color:#333333"><strong>void</strong></span> <span style="color:#990000"><strong>run</strong></span>() {
                <span style="color:#333333"><strong>long</strong></span> prepareTime = random.nextInt(<span style="color:#008080">10000</span>) + <span style="color:#008080">100</span>;
                System.out.println(rN + <span style="color:#dd1144">"is preparing for time:"</span> + prepareTime);
                <span style="color:#333333"><strong>try</strong></span> {
                    Thread.sleep(prepareTime);
                } <span style="color:#333333"><strong>catch</strong></span> (Exception e) {
                    e.printStackTrace();
                }
                <span style="color:#333333"><strong>try</strong></span> {
                    System.out.println(rN + <span style="color:#dd1144">"is prepared, waiting for others"</span>);
                    cyclicBarrier.await(); <span style="color:#999988">// The current runner is ready, waiting for others to be ready</span>
                } <span style="color:#333333"><strong>catch</strong></span> (InterruptedException e) {
                    e.printStackTrace();
                } <span style="color:#333333"><strong>catch</strong></span> (BrokenBarrierException e) {
                    e.printStackTrace();
                }
                System.out.println(rN + <span style="color:#dd1144">"starts running"</span>); <span style="color:#999988">// All the runners are ready to start running together</span>
            }
        }).start();
    }
}</code></span>

结果如下：

<span style="color:#333333"><code class="language-bash"><span style="color:#445588"><strong>A</strong></span> <span style="color:#333333"><strong>is</strong></span> preparing <span style="color:#333333"><strong>for</strong></span> time: <span style="color:#008080">4131</span>
<span style="color:#445588"><strong>B</strong></span> <span style="color:#333333"><strong>is</strong></span> preparing <span style="color:#333333"><strong>for</strong></span> time: <span style="color:#008080">6349</span>
<span style="color:#445588"><strong>C</strong></span> <span style="color:#333333"><strong>is</strong></span> preparing <span style="color:#333333"><strong>for</strong></span> time: <span style="color:#008080">8206</span>
 
<span style="color:#445588"><strong>A</strong></span> <span style="color:#333333"><strong>is</strong></span> prepared, waiting <span style="color:#333333"><strong>for</strong></span> others
 
<span style="color:#445588"><strong>B</strong></span> <span style="color:#333333"><strong>is</strong></span> prepared, waiting <span style="color:#333333"><strong>for</strong></span> others
 
<span style="color:#445588"><strong>C</strong></span> <span style="color:#333333"><strong>is</strong></span> prepared, waiting <span style="color:#333333"><strong>for</strong></span> others
 
<span style="color:#445588"><strong>C</strong></span> starts running
<span style="color:#445588"><strong>A</strong></span> starts running
<span style="color:#445588"><strong>B</strong></span> starts running</code></span>

子线程将结果返回到主线程

在实际开发中，我们经常需要创建子线程来执行一些耗时的任务，然后将执行结果传递回主线程。那么如何在Java中实现呢？

所以通常，在创建线程时，我们会将Runnable对象传递给Thread进行执行。Runnable的定义如下：

<span style="color:#333333"><code class="language-java"><span style="color:#333333"><strong>public</strong></span> <span style="color:#333333"><strong>interface</strong></span> <span style="color:#445588"><strong>Runnable</strong></span> {
    <span style="color:#333333"><strong>public</strong></span> <span style="color:#333333"><strong>abstract</strong></span> <span style="color:#333333"><strong>void</strong></span> <span style="color:#990000"><strong>run</strong></span>();
}</code></span>

您可以看到该run()方法在执行后不会返回任何结果。如果你想返回结果怎么办？在这里你可以使用另一个类似的接口类Callable：

<span style="color:#333333"><code class="language-java"><span style="color:#999999"><strong>@FunctionalInterface</strong></span>
<span style="color:#333333"><strong>public</strong></span> <span style="color:#333333"><strong>interface</strong></span> <span style="color:#445588"><strong>Callable</strong></span><<span style="color:#445588"><strong>V</strong></span>> {
    <span style="color:#999988">/**
     * Computes a result, or throws an exception if unable to do so.
     *
     * <span style="color:#dd1144">@return</span> computed result
     * <span style="color:#dd1144">@throws</span> Exception if unable to compute a result
     */</span>
    V <span style="color:#990000"><strong>call</strong></span>() <span style="color:#333333"><strong>throws</strong></span> Exception;
}</code></span>

可以看出，最大的区别Callable在于它返回了泛型。

那么接下来的问题是，如何将子线程的结果传回去？Java有一个FutureTask可以使用的类Callable，但请注意，get用于获取结果的方法将阻塞主线程。

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

<span style="color:#333333"><code class="language-java"><span style="color:#333333"><strong>private</strong></span> <span style="color:#333333"><strong>static</strong></span> <span style="color:#333333"><strong>void</strong></span> <span style="color:#990000"><strong>doTaskWithResultInWorker</strong></span>() {
    Callable<Integer> callable = <span style="color:#333333"><strong>new</strong></span> Callable<Integer>() {
        @Override
        <span style="color:#333333"><strong>public</strong></span> Integer <span style="color:#990000"><strong>call</strong></span>() throws Exception {
            System.<span style="color:#333333"><strong>out</strong></span>.println(<span style="color:#dd1144">"Task starts"</span>);
            Thread.sleep(<span style="color:#008080">1000</span>);
            <span style="color:#333333"><strong>int</strong></span> result = <span style="color:#008080">0</span>;
            <span style="color:#333333"><strong>for</strong></span> (<span style="color:#333333"><strong>int</strong></span> i=<span style="color:#008080">0</span>; i<=<span style="color:#008080">100</span>; i++) {
                result += i;
            }
            System.<span style="color:#333333"><strong>out</strong></span>.println(<span style="color:#dd1144">"Task finished and return result"</span>);
            <span style="color:#333333"><strong>return</strong></span> result;
        }
    };
    FutureTask<Integer> futureTask = <span style="color:#333333"><strong>new</strong></span> FutureTask<>(callable);
    <span style="color:#333333"><strong>new</strong></span> Thread(futureTask).start();
    <span style="color:#333333"><strong>try</strong></span> {
        System.<span style="color:#333333"><strong>out</strong></span>.println(<span style="color:#dd1144">"Before futureTask.get()"</span>);
        System.<span style="color:#333333"><strong>out</strong></span>.println(<span style="color:#dd1144">"Result:"</span> + futureTask.<span style="color:#333333"><strong>get</strong></span>());
        System.<span style="color:#333333"><strong>out</strong></span>.println(<span style="color:#dd1144">"After futureTask.get()"</span>);
    } <span style="color:#333333"><strong>catch</strong></span> (InterruptedException e) {
        e.printStackTrace();
    } <span style="color:#333333"><strong>catch</strong></span> (ExecutionException e) {
        e.printStackTrace();
    }
}</code></span>

结果如下：

<span style="color:#333333"><code class="language-bash"><span style="color:#445588"><strong>Before</strong></span> futureTask.<span style="color:#333333"><strong>get</strong></span>()
 
<span style="color:#445588"><strong>Task</strong></span> starts
<span style="color:#445588"><strong>Task</strong></span> finished and <span style="color:#333333"><strong>return</strong></span> result
 
<span style="color:#445588"><strong>Result</strong></span>: <span style="color:#008080">5050</span>
<span style="color:#445588"><strong>After</strong></span> futureTask.<span style="color:#333333"><strong>get</strong></span>()</code></span>

可以看出，当主线程调用该futureTask.get()方法时，它会阻塞主线程; 然后Callable开始在内部执行并返回操作的结果; 然后futureTask.get()获取结果，主线程恢复运行。

在这里我们可以了解到FutureTask并且Callable可以直接在主线程中获取子线程的结果，但是它们会阻塞主线程。当然，如果您不想阻止主线程，可以考虑使用ExecutorService放入FutureTask线程池来管理执行。

摘要

多线程是现代语言的常见功能，线程间通信，线程同步和线程安全是非常重要的主题。

 

原文地址：https://www.tutorialdocs.com/article/java-inter-thread-communication.html

mosquitolww
关注
Java面试题：如何在Java中实现线程间的通信？请列举几种常见的方式
杰哥在此的专栏
06-02 576
线程可以通过共享对象的实例变量或方法参数来进行通信。在Java中，线程间的通信主要涉及到线程间的数据交换和协调。这些线程间通信的方式各有特点和适用场景，开发者可以根据具体的应用需求选择合适的通信机制。方法，它们可以用来在线程间进行阻塞和唤醒操作，实现线程间的协调。是一个线程安全的队列，可以用于生产者-消费者模式中的线程间通信。是一个可以在两个线程间交换数据的同步辅助类。接口提供了更高级的锁和条件对象，可以实现复杂的线程间通信。关键字声明的变量可以确保所有线程看到的是最新的值，因为对。
Java管道流实现线程间通信过程解析
08-19
Java管道流实现线程间通信过程解析 Java管道流是一种特殊的流，用于在不同线程间直接传送数据。它提供了一种高效、可靠的线程间通信方式，能够帮助开发者更好地实现线程间的数据交换。在Java语言中，管道流是通过...
Java 如何实现线程间通信
weixin_34252090的博客
09-13 660
正常情况下，每个子线程完成各自的任务就可以结束了。不过有的时候，我们希望多个线程协同工作来完成某个任务，这时就涉及到了线程间通信了。 本文涉及到的知识点： thread.join(), object.wait(), object.notify(), CountdownLatch, CyclicBarrier, FutureTask, ...
Java里如何实现线程间通信？
djwmzyl的专栏
04-17 3730
正常情况下，每个子线程完成各自的任务就可以结束了。不过有的时候，我们希望多个线程协同工作来完成某个任务，这时就涉及到了线程间通信了。 本文涉及到的知识点：thread.join(), object.wait(), object.notify(), CountdownLatch, CyclicBarrier, FutureTask, Callable 等。 下面我从几个例子作为切入点
多线程之间实现通讯
飞上云端看彩虹
05-11 959
多线程之间如何实现通讯 什么是多线程之间通讯？  多线程之间通讯，其实就是多个线程在操作同一个资源，但是操作的动作不同。 多线程之间通讯需求   需求:第一个线程写入(input)用户，另一个线程取读取(out)用户.实现读一个，写一个操作。 注意：数据发生错乱，造成线程安全问题 解决线程安全问题 IntThrad 加上synchronized 输出线程加上synchroniz...
【转】Java学习：Java中的线程之线程间的通信
weixin_30929195的博客
06-30 163
hello各位小伙伴 今天我们来搞一下 线程之间的通信 ( • ̀ω•́ )✧ 让线程按照我们的想法来执行 两个线程间的通信 这是我们之前的线程。 执行效果：谁抢到资源，谁运行~ 实现线程交替执行： 这里主要用到了两个内容 1）创建一个标记 flag，让程序进行判断： 当flag != 1 时，print1 进入等待，执行 print2，然后让 flag=1，唤醒...
浅析Java中如何实现线程之间通信
08-30
在Java中，有多种方式可以实现线程间的通信，以下将详细解释并举例说明这些方法。 1. **线程的join()方法**： `join()` 方法允许一个线程等待另一个线程完成其执行。在上面的示例中，`A.join()` 让线程 B 在线程 A...
深入理解JAVA多线程之线程间的通信方式
09-02
除了上述两种方式，Java还提供了其他线程间通信的方法： 3. Wait/Notify机制： `wait()`, `notify()`, `notifyAll()`是Object类提供的方法，用于线程间通信。在线程A执行完特定操作后，可以调用`notify()`或`...
Java线程间的通信方式详解
09-02
Java线程间的通信是多线程编程中的重要概念，它涉及到如何协调多个并发执行的线程，确保数据的一致性和正确性。本文将详细介绍两种常见的Java线程通信方式：同步和while轮询。 1. 同步（Synchronized） 同步是Java...
java中线程间如何进行通信_Java线程间如何通信（五）
weixin_30582943的博客
02-23 260
1、简述线程是操作系统中独立的个体，但这些个体如果不经过特殊的处理就不能称为一个整体。使线程之间进行通信后，在大大提高CPU利用率的同时还会使开发人员对各个线程任务在处理的过程中进行有效的把控。2、如何实现线程间通信2.1、等待(wait)/通知机制(notify)方法 wait() 说明方法wait()的作用是使当前执行的线程进行等待，wait() 方法是Object 类的方法，该方法用来将当前...
如何在java中实现线程间的通信【翻译】
糖醋闷油瓶的博客
02-20 272
虽然在通常情况下每个子线程仅需要完成自己的任务即可，但是有时候我们会需要不同的线程一起协作解决某个问题，此时便需要进行线程之间的通信了。 以下的这些方法或者类将会在接下来的内容中提及： hread.join(), object.wait(), object.notify(), CountdownLatch, CyclicBarrier, FutureTask, Callable, etc. 我将...
java 怎么实现线程通信_Java中线程之间的通信是如何实现的
weixin_32459883的博客
02-26 134
Java中线程之间的通信是如何实现的发布时间：2020-11-17 15:15:09来源：亿速云阅读：100作者：Leah这篇文章将为大家详细讲解有关Java中线程之间的通信是如何实现的，文章内容质量较高，因此小编分享给大家做个参考，希望大家阅读完这篇文章后对相关知识有一定的了解。正常情况下，每个子线程完成各自的任务就可以结束了。不过有的时候，我们希望多个线程协同工作来完成某个任务，这时就涉及到了...
Java 中如何实现线程间通信
java111112313213的博客
09-10 181
世界以痛吻我，要我报之以歌 —— 泰戈尔《飞鸟集》 虽然通常每个子线程只需要完成自己的任务，但是有时我们希望多个线程一起工作来完成一个任务，这就涉及到线程间通信。 关于线程间通信本文涉及到的方法和类包括：thread.join()、object.wait()、object.notify()、CountdownLatch、CyclicBarrier、FutureTask、Callable。 接下来将用几个例子来介绍如何在Java中实现线程间通信： 如何让两个线程依次执行，即一个线程等待另一个线程执.
Java 是如何实现线程间通信的？
mischen520的博客
09-21 337
正常情况下，每个子线程完成各自的任务就可以结束了。不过有的时候，我们希望多个线程协同工作来完成某个任务，这时就涉及到了线程间通信了。 本文涉及到的知识点： thread.join(), object.wait(), object.notify(), CountdownLatch, CyclicBarrier, FutureTask, Callable 。 下面我从几个例子作为切入点来讲解下 Java 里有哪些方法来实现线程间通信。 如何让两个线程依次执行？ 那如何让 两个线程按照指定方式有序交叉运行呢？ 四
Java 里如何实现线程间通信？
橙子wj的博客
10-11 645
出处： http://wingjay.com/2017/04/09/Java%E9%87%8C%E5%A6%82%E4%BD%95%E5%AE%9E%E7%8E%B0%E7%BA%BF%E7%A8%8B%E9%97%B4%E9%80%9A%E4%BF%A1%EF%BC%9F/正常情况下，每个子线程完成各自的任务就可以结束了。不过有的时候，我们希望多个线程协同工作来完成某个任务，这时就涉及到了线程间
java线程间如何通信
weixin_35749440的博客
02-11 313
Java线程之间可以通过以下方式进行通信： 使用 wait() 和 notify() 方法，这需要使用同步代码块或同步方法。在同步代码块或同步方法中，线程可以调用 wait() 方法阻塞，并在其他线程调用 notify() 方法后恢复执行。 使用 CountDownLatch，它是一个同步辅助类，可以让一个线程等待其他线程的完成。 使用 CyclicBarrier，它也是一个同步辅助类，可以...
java如何进行线程的通信_线程如何在Java中相互通信？
weixin_33438788的博客
02-27 115
线程间通信使线程之间的通信不断发展。用于在Java中实现线程间通信的三种方法等待()此方法使当前线程释放锁。直到完成特定时间段或另一个线程为此对象调用notify()或notifyAll()方法，该操作才完成。通知()此方法从当前对象的监视器上的多个线程中唤醒一个线程。线程的选择是任意的。notifyAll()此方法唤醒当前对象监视器上的所有线程。示例classBankClient{intb...
Java线程通信
baolingye的博客
06-05 382
Java线程通信 假设现在系统中有两个线程，分别代表取钱和存钱，现在假设系统有一种特殊的要求，系统要求存款者和取款者不断重复存取款，而且要求每当存款者将钱存入指定账户时，取钱者就立即取出该笔钱，不允许连续存款两次，也不允许连续取款两次 实现思路 设置一个标识 当账户有钱时，存钱线程阻塞，并通知取钱线程取钱 当账户没有钱时，取钱线程阻塞，并通知存钱线程存钱 public class Thr...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值