Java 是如何实现线程间通信的？

最新推荐文章于 2024-09-20 10:16:33 发布
最新推荐文章于 2024-09-20 10:16:33 发布
阅读量127 收藏
点赞数
文章标签： 多线程 并发编程
原文链接：blog.csdn.net/lanxian837820149/article/details/101479004
版权

正常情况下，每个子线程完成各自的任务就可以结束了。不过有的时候，我们希望多个线程协同工作来完成某个任务，这时就涉及到了线程间通信了。

本文涉及到的知识点：

  1. thread.join(),
  2. object.wait(),
  3. object.notify(),
  4. CountdownLatch,
  5. CyclicBarrier,
  6. FutureTask,
  7. Callable 。

本文涉及代码： https://github.com/wingjay/HelloJava/blob/master/multi-thread/src/ForArticle.java

下面我从几个例子作为切入点来讲解下 Java 里有哪些方法来实现线程间通信。

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

如何让两个线程依次执行？

假设有两个线程，一个是线程 A，另一个是线程 B，两个线程分别依次打印 1-3 三个数字即可。我们来看下代码：

private static void demo1() {  
    Thread A = new Thread(new Runnable() {  
        @Override  
        public void run() {  
            printNumber("A");  
        }  
    });  
    Thread B = new Thread(new Runnable() {  
        @Override  
        public void run() {  
            printNumber("B");  
        }  
    });  
    A.start();  
    B.start();  
}

其中的 printNumber(String) 实现如下，用来依次打印 1, 2, 3 三个数字：

private static void printNumber(String threadName) {  
    int i=0;  
    while (i++ < 3) {  
        try {  
            Thread.sleep(100);  
        } catch (InterruptedException e) {  
            e.printStackTrace();  
        }  
        System.out.println(threadName + " print: " + i);  
    }  
}

这时我们得到的结果是：

B print: 1 A print: 1 B print: 2 A print: 2 B print: 3 A print: 3

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

那么，如果我们希望 B 在 A 全部打印 完后再开始打印呢？我们可以利用 thread.join() 方法，代码如下:

private static void demo2() {  
    Thread A = new Thread(new Runnable() {  
        @Override  
        public void run() {  
            printNumber("A");  
        }  
    });  
    Thread B = new Thread(new Runnable() {  
        @Override  
        public void run() {  
            System.out.println("B 开始等待 A");  
            try {  
                A.join();  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
            printNumber("B");  
        }  
    });  
    B.start();  
    A.start();  
}

得到的结果如下：

B 开始等待 A A print: 1 A print: 2 A print: 3 B print: 1 B print: 2 B print: 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  
 */  
private static void demo3() {  
    Object lock = new Object();  
    Thread A = new Thread(new Runnable() {  
        @Override  
        public void run() {  
            synchronized (lock) {  
                System.out.println("A 1");  
                try {  
                    lock.wait();  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
                System.out.println("A 2");  
                System.out.println("A 3");  
            }  
        }  
    });  
    Thread B = new Thread(new Runnable() {  
        @Override  
        public void run() {  
            synchronized (lock) {  
                System.out.println("B 1");  
                System.out.println("B 2");  
                System.out.println("B 3");  
                lock.notify();  
            }  
        }  
    });  
    A.start();  
    B.start();  
}

打印结果如下：

A 1 A waiting…
B 1 B 2 B 3 A 2 A 3

正是我们要的结果。

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

  1. 首先创建一个 A 和 B 共享的对象锁 lock = new Object();
  2. 当 A 得到锁后，先打印 1，然后调用 lock.wait() 方法，交出锁的控制权，进入 wait 状态；
  3. 对 B 而言，由于 A 最开始得到了锁，导致 B 无法执行；直到 A 调用 lock.wait() 释放控制权后， B 才得到了锁；
  4. B 在得到锁后打印 1， 2， 3；然后调用 lock.notify() 方法，唤醒正在 wait 的 A;
  5. A 被唤醒后，继续打印剩下的 2，3。
    为了更好理解，我在上面的代码里加上 log 方便读者查看。
private static void demo3() {  
    Object lock = new Object();  
    Thread A = new Thread(new Runnable() {  
        @Override  
        public void run() {  
            System.out.println("INFO: A 等待锁 ");  
            synchronized (lock) {  
                System.out.println("INFO: A 得到了锁 lock");  
                System.out.println("A 1");  
                try {  
                    System.out.println("INFO: A 准备进入等待状态，放弃锁 lock 的控制权 ");  
                    lock.wait();  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                }  
                System.out.println("INFO: 有人唤醒了 A, A 重新获得锁 lock");  
                System.out.println("A 2");  
                System.out.println("A 3");  
            }  
        }  
    });  
    Thread B = new Thread(new Runnable() {  
        @Override  
        public void run() {  
            System.out.println("INFO: B 等待锁 ");  
            synchronized (lock) {  
                System.out.println("INFO: B 得到了锁 lock");  
                System.out.println("B 1");  
                System.out.println("B 2");  
                System.out.println("B 3");  
                System.out.println("INFO: B 打印完毕，调用 notify 方法 ");  
                lock.notify();  
            }  
        }  
    });  
    A.start();  
    B.start();  
}

打印结果如下:

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

四个线程 A B C D，其中 D 要等到 A B C 全执行完毕后才执行，而且 A B C 是同步运行的

最开始我们介绍了 thread.join()，可以让一个线程等另一个线程运行完毕后再继续执行，那我们可以在 D 线程里依次 join A B C，不过这也就使得 A B C 必须依次执行，而我们要的是这三者能同步运行。

或者说，我们希望达到的目的是：A B C 三个线程同时运行，各自独立运行完后通知 D；对 D 而言，只要 A B C 都运行完了，D 再开始运行。针对这种情况，我们可以利用 CountdownLatch 来实现这类通信方式。它的基本用法是：

  1. 创建一个计数器，设置初始值，CountdownLatch countDownLatch = new CountDownLatch(2);
  2. 在 等待线程 里调用 countDownLatch.await() 方法，进入等待状态，直到计数值变成 0；
  3. 在 其他线程 里，调用 countDownLatch.countDown() 方法，该方法会将计数值减小 1；
  4. 当 其他线程 的 countDown() 方法把计数值变成 0 时，等待线程 里的 countDownLatch.await() 立即退出，继续执行下面的代码。
    实现代码如下：
private static void runDAfterABC() {  
    int worker = 3;  
    CountDownLatch countDownLatch = new CountDownLatch(worker);  
    new Thread(new Runnable() {  
        @Override  
        public void run() {  
            System.out.println("D is waiting for other three threads");  
            try {  
                countDownLatch.await();  
                System.out.println("All done, D starts working");  
            } catch (InterruptedException e) {  
                e.printStackTrace();  
            }  
        }  
    }).start();  
    for (char threadName='A'; threadName <= 'C'; threadName++) {  
        final String tN = String.valueOf(threadName);  
        new Thread(new Runnable() {  
            @Override  
            public void run() {  
                System.out.println(tN + " is working");  
                try {  
                    Thread.sleep(100);  
                } catch (Exception e) {  
                    e.printStackTrace();  
                }  
                System.out.println(tN + " finished");  
                countDownLatch.countDown();  
            }  
        }).start();  
    }  
}

下面是运行结果：

D is waiting for other three threads A is working B is working C is working
A finished C finished B finished All done, D starts working

其实简单点来说，CountDownLatch 就是一个倒计数器，我们把初始计数值设置为3，当 D 运行时，先调用 countDownLatch.await() 检查计数器值是否为 0，若不为 0 则保持等待状态；当A B C 各自运行完后都会利用countDownLatch.countDown()，将倒计数器减 1，当三个都运行完后，计数器被减至 0；此时立即触发 D 的 await() 运行结束，继续向下执行。

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

三个运动员各自准备，等到三个人都准备好后，再一起跑

上面是一个形象的比喻，针对 线程 A B C 各自开始准备，直到三者都准备完毕，然后再同时运行 。也就是要实现一种 线程之间互相等待 的效果，那应该怎么来实现呢？

上面的 CountDownLatch 可以用来倒计数，但当计数完毕，只有一个线程的 await() 会得到响应，无法让多个线程同时触发。

为了实现线程间互相等待这种需求，我们可以利用 CyclicBarrier 数据结构，它的基本用法是：

  1. 先创建一个公共 CyclicBarrier 对象，设置 同时等待 的线程数，CyclicBarrier cyclicBarrier = new CyclicBarrier(3);
  2. 这些线程同时开始自己做准备，自身准备完毕后，需要等待别人准备完毕，这时调用 cyclicBarrier.await(); 即可开始等待别人；
  3. 当指定的 同时等待 的线程数都调用了 cyclicBarrier.await();时，意味着这些线程都准备完毕好，然后这些线程才 同时继续执行。
    实现代码如下，设想有三个跑步运动员，各自准备好后等待其他人，全部准备好后才开始跑：
private static void runABCWhenAllReady() {  
    int runner = 3;  
    CyclicBarrier cyclicBarrier = new CyclicBarrier(runner);  
    final Random random = new Random();  
    for (char runnerName='A'; runnerName <= 'C'; runnerName++) {  
        final String rN = String.valueOf(runnerName);  
        new Thread(new Runnable() {  
            @Override  
            public void run() {  
                long prepareTime = random.nextInt(10000) + 100;  
                System.out.println(rN + " is preparing for time: " + prepareTime);  
                try {  
                    Thread.sleep(prepareTime);  
                } catch (Exception e) {  
                    e.printStackTrace();  
                }  
                try {  
                    System.out.println(rN + " is prepared, waiting for others");  
                    cyclicBarrier.await(); // 当前运动员准备完毕，等待别人准备好  
                } catch (InterruptedException e) {  
                    e.printStackTrace();  
                } catch (BrokenBarrierException e) {  
                    e.printStackTrace();  
                }  
                System.out.println(rN + " starts running"); // 所有运动员都准备好了，一起开始跑  
            }  
        }).start();  
    }  
}

打印的结果如下：

A is preparing for time: 4131 B is preparing for time: 6349 C is preparing for time: 8206 A is prepared, >waiting for others B is prepared, waiting for others C is prepared, waiting for others C starts running A >starts running B starts running

子线程完成某件任务后，把得到的结果回传给主线程

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

回顾线程的创建，我们一般会把 Runnable 对象传给 Thread 去执行。Runnable定义如下：

public interface Runnable {  
    public abstract void run();  
}

可以看到 run() 在执行完后不会返回任何结果。那如果希望返回结果呢？这里可以利用另一个类似的接口类 Callable：

@FunctionalInterface  
public interface Callable<V> {  
    /**  
     * Computes a result, or throws an exception if unable to do so.  
     *  
     * @return computed result  
     * @throws Exception if unable to compute a result  
     */  
    V call() throws Exception;  
}

可以看出 Callable 最大区别就是返回范型 V 结果。

那么下一个问题就是，如何把子线程的结果回传回来呢？在 Java 里，有一个类是配合 Callable 使用的：FutureTask，不过注意，它获取结果的 get 方法会阻塞主线程。

举例，我们想让子线程去计算从 1 加到 100，并把算出的结果返回到主线程。

private static void doTaskWithResultInWorker() {  
    Callable<Integer> callable = new Callable<Integer>() {  
        @Override  
        public Integer call() throws Exception {  
            System.out.println("Task starts");  
            Thread.sleep(1000);  
            int result = 0;  
            for (int i=0; i<=100; i++) {  
                result += i;  
            }  
            System.out.println("Task finished and return result");  
            return result;  
        }  
    };  
    FutureTask<Integer> futureTask = new FutureTask<>(callable);  
    new Thread(futureTask).start();  
    try {  
        System.out.println("Before futureTask.get()");  
        System.out.println("Result: " + futureTask.get());  
        System.out.println("After futureTask.get()");  
    } catch (InterruptedException e) {  
        e.printStackTrace();  
    } catch (ExecutionException e) {  
        e.printStackTrace();  
    }  
}

打印结果如下：

Before futureTask.get() Task starts Task finished and return result Result: 5050 After futureTask.get()

可以看到，主线程调用 futureTask.get() 方法时阻塞主线程；然后 Callable 内部开始执行，并返回运算结果；此时 futureTask.get() 得到结果，主线程恢复运行。

这里我们可以学到，通过 FutureTask 和 Callable 可以直接在主线程获得子线程的运算结果，只不过需要阻塞主线程。当然，如果不希望阻塞主线程，可以考虑利用 ExecutorService，把 FutureTask 放到线程池去管理执行。

小结

多线程是现代语言的共同特性，而线程间通信、线程同步、线程安全是很重要的话题。本文针对 Java 的线程间通信进行了大致的讲解，后续还会对线程同步、线程安全进行讲解

一滴水的眼泪
关注
Java 如何实现线程间通信
weixin_34252090的博客
09-13 578
正常情况下，每个子线程完成各自的任务就可以结束了。不过有的时候，我们希望多个线程协同工作来完成某个任务，这时就涉及到了线程间通信了。 本文涉及到的知识点： thread.join(), object.wait(), object.notify(), CountdownLatch, CyclicBarrier, FutureTask, ...
java 线程之间是如何通信的
SICAUliuy的博客
04-20 4231
java线程之间的通信方式总共有 8 种，分别是 volatile、synchronized、interrupt、wait、notify、notifyAll、join、管道输入/输出， 我们一个一个的来说明！ 1.volatile 线程会将内存中的数据，拷贝到各自的本地内存中( 这里的本地内存指的是 cpu cache ( 比如 CPU 的一级缓存、二级缓存等 )，寄存器)。当某个变量被 volatile 修饰并且发生改变时，volatile 变量底层会通过 lock前缀的指令，将该变量写会主存，同时利用
Java中线程之间是如何通信的
最新发布
yymagicer的博客
09-20 1487
在 Java 中，线程之间的通信是通过模型来实现的，线程通过共享的对象和变量来交换数据。为了确保线程间通信的正确性，Java 提供了一系列机制来实现线程安全、同步和通信。以下是常用的几种线程间通信的方式，以及它们的使用方法和场景。
java线程间如何通信
weixin_42608299的博客
02-11 898
Java线程之间可以通过以下方式进行通信： 使用 wait() 和 notify() 方法，这需要使用同步代码块或同步方法。在同步代码块或同步方法中，线程可以调用 wait() 方法阻塞，并在其他线程调用 notify() 方法后恢复执行。 使用 CountDownLatch，它是一个同步辅助类，可以让一个线程等待其他线程的完成。 使用 CyclicBarrier，它也是一个同步辅助类，可以...
JAVA两个线程之间是如何通信的？
xycxycooo的博客
08-07 405
共享变量：通过同步机制保护共享变量的访问，实现线程之间的通信。wait和notifynotifyAll：通过等待和通知机制实现线程之间的通信。Condition接口：提供更灵活的等待和通知机制，通常与一起使用。：通过线程安全的队列实现生产者-消费者模式，实现线程之间的通信。
Java管道流实现线程间通信过程解析
08-19
Java管道流实现线程间通信过程解析 Java管道流是一种特殊的流，用于在不同线程间直接传送数据。它提供了一种高效、可靠的线程间通信方式，能够帮助开发者更好地实现线程间的数据交换。在Java语言中，管道流是通过...
深入理解JAVA多线程之线程间的通信方式
09-02
除了上述两种方式，Java还提供了其他线程间通信的方法： 3. Wait/Notify机制： `wait()`, `notify()`, `notifyAll()`是Object类提供的方法，用于线程间通信。在线程A执行完特定操作后，可以调用`notify()`或`...
Java线程间的通信方式详解
09-02
Java线程间的通信是多线程编程中的重要概念，它涉及到如何协调多个并发执行的线程，确保数据的一致性和正确性。本文将详细介绍两种常见的Java线程通信方式：同步和while轮询。 1. 同步（Synchronized） 同步是Java...
浅析Java中如何实现线程之间通信
08-30
Java中的线程间通信是多线程编程中的关键概念，它允许不同线程间共享数据、协调执行顺序，以实现复杂任务的同步。在Java中，有多种方式可以实现线程间的通信，以下将详细解释并举例说明这些方法。 1. **线程的join...
Java通过wait()和notifyAll()方法实现线程间通信
08-30
在Java多线程编程中，线程间通信是至关重要的，它使得多个线程能够协作完成复杂的任务。Java提供了一套基于对象监视器机制的线程通信方式，其中包括`wait()`、`notify()`和`notifyAll()`方法。这些方法都是在`java....
Java线程之间通信方式
赵广陆
09-09 2292
目录 1 线程之间的通信方式主要有以下几种 2 共享变量 3 锁机制 4 条件变量 5 信号量 6 管道 6 join方法的实现原理 7 join方法实现顺序性原理 1 线程之间的通信方式主要有以下几种 在实际开发时，一个进程中往往有很多个线程，大多数线程之间往往不是绝对独立的，比如说我们需要将A和B 两个线程的执行结果收集在一起然后显示在界面上，又或者比较典型的消费者-生产者模式，在这些场景下，线程间通信成了我们必须使用的手段，那么线程之间怎么通信呢？
Java线程之间如何通信的，有哪些方式？
Ascend1977的博客
05-29 6197
尽可能避免共享变量，因为共享变量容易引起线程安全问题。对共享变量的访问需要加锁，以保证同步访问。避免死锁问题的发生。使用锁时需要特别注意加锁和释放锁的顺序。使用条件变量时，应该确保线程在调用 await() 方法之前已经获取了锁。否则，在等待条件成立的过程中，其他线程可能会修改共享资源，导致程序出现错误。 在使用信号量时，需要正确设置信号量的个数和调用 acquire() 和 release() 方法的顺序，否则可能会出现线程阻塞或信号量无法释放的情况。管道的使用需要注意线程之间的数据传输方式，以及缓冲区的
Java中的线程通信的几种方式
u013749113的博客
05-17 1615
Java中提供了多种方式来实现线程间通信，其中最常见的方式包括synchronized关键字、wait()和notify()方法、CountDownLatch类、Semaphore类和BlockingQueue类。这些方式都可以用来实现线程之间的互斥、同步、数据共享和通信。选择哪种方式取决于具体的应用场景和需求。在使用这些方式时，需要注意线程安全和死锁等问题，以确保程序的正确性和健壮性。
Java - 线程间的通信方式
m0_65228708的博客
12-10 1483
线程通信的方式 共享内存 消息传递 管道输入/输出流
Java线程间的通信方式
Wdradon的博客
06-27 5406
**定义：**当多个线程共同操作共享的资源时，线程间通过某种方式互相告知自己的状态，以避免无效的资源争夺。通信的方式：**线程同步：**即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作。同步的话，仅仅传递的是控制信息，就是我什么时候运行结束，你什么时候可以来。对于线程间通信来说，线程间同步可以归纳为线程间通信的一个子集，对于线程通信指的是两个线程之间可以交换一些实时的数据信息，而线程同步只交换一些控制信息。在java中有几个关于
Java并发学习 7: 线程之间的通信
过道
04-10 2871
3.1 继承 Thread类 // 继承，则Demo1 也成为了一个线程 public class Demo1 extends Thread { // 继承Thread类，需要重写run()方法，告诉这个类需要去坐什么. @Override public void run() { // 这个新类，只需要打印出自己的名字(每个线程都有自己的Name属性并提供g...
【Java进阶】Java线程间通讯的几种方式
热门推荐
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
11-06 2万+
一、使用同一个共享变量控制 Synchronized、wait、notifyLock、Condition利用volatile利用AtomicInteger二、PipedInputStream、PipedOutputStream 三、利用BlockingQueue
Java 线程间通信
WYSCODER的博客
04-17 5763
Java线程间通信
Java实现多线程通信详解
- **等待与通知**：`wait()`, `notify()`, `notifyAll()`方法是线程间通信的关键。这些方法必须在`synchronized`代码块或方法中使用，以避免死锁和其他并发问题。一个线程调用`wait()`会释放它持有的锁并进入等待...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值