Java零基础之多线程篇：线程间如何通信？

喵手

于 2024-08-03 00:11:12 发布

阅读量1k

点赞数 20

分类专栏：零基础学Java 文章标签： java 开发语言多线程线程通信

本文链接：https://blog.csdn.net/weixin_66592566/article/details/137697597

版权

零基础学Java 专栏收录该内容

344 篇文章 7 订阅

订阅专栏

哈喽，各位小伙伴们，你们好呀，我是喵手。运营社区：C站/掘金/腾讯云；欢迎大家常来逛逛

今天我要给大家分享一些自己日常学习到的一些知识点，并以文字的形式跟大家一起交流，互相学习，一个人虽可以走的更快，但一群人可以走的更远。

我是一名后端开发爱好者，工作日常接触到最多的就是Java语言啦，所以我都尽量抽业余时间把自己所学到所会的，通过文章的形式进行输出，希望以这种方式帮助到更多的初学者或者想入门的小伙伴们，同时也能对自己的技术进行沉淀，加以复盘，查缺补漏。

小伙伴们在批阅的过程中，如果觉得文章不错，欢迎点赞、收藏、关注哦。三连即是对作者我写作道路上最好的鼓励与支持！

前言

随着计算机技术的发展，多线程编程已经成为现代软件开发中的一个重要方向。在多线程编程中，线程间的通信是一个非常关键的问题。在Java开发语言中，Java提供了一些机制来实现线程间的通信，帮助开发者协调不同线程之间的执行顺序和数据交换。

摘要

本文将介绍Java多线程编程中的线程间通信的相关知识。首先，我们将从简介开始，介绍线程间通信的基本概念和原理。然后，我们将通过源代码解析的方式，深入探讨Java中实现线程间通信的方法。接着，我们将给出一些应用场景案例，展示线程间通信在实际开发中的应用。随后，我们将对线程间通信的优缺点进行分析，帮助读者了解线程间通信的适用性。最后，我们将介绍一些常用的类和方法，用于实现线程间通信，并提供具体的Java代码测试用例。全文将以markdown的语法编写，并保证全文内容衔接清晰。

简介

在多线程编程中，线程是独立的执行单元，它们可以并发地执行任务。然而，在某些情况下，不同线程之间需要进行数据交换或者协作来完成复杂的任务。为了实现线程间的通信，Java提供了以下几种机制：

共享变量：多个线程共享同一个变量，在访问该变量时需要加锁来保证线程安全。
管道（Pipe）：线程通过管道进行数据通信，其中一个线程作为输入流，另一个线程作为输出流。
消息队列（MessageQueue）：线程通过消息队列进行数据交换，发送方将消息放入消息队列，接收方从消息队列中获取消息。
信号量（Semaphore）：限制同时访问某个资源的线程数量，通过信号量可以实现线程间的同步和互斥。
读写锁（ReadWriteLock）：实现读写分离的锁机制，读操作可以并发执行，写操作需要互斥执行。
条件（Condition）：线程可以根据条件进行等待和唤醒，从而实现线程间的协作。

源代码解析

以下是使用共享变量实现线程间通信的示例代码：

package com.example.javase.ms.threadDemo.day5;

/**
 * @Author ms
 * @Date 2024-04-12 23:00
 */
public class SharedData {
    private int data;
    private boolean isReady = false;

    public synchronized int getData() {
        while (!isReady) {
            try {
                wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        return data;
    }

    public synchronized void setData(int value) {
        data = value;
        isReady = true;
        notifyAll();
    }

    public static void main(String[] args) {
        SharedData sharedData = new SharedData();
        new Thread(new Reader(sharedData)).start();
        new Thread(new Writer(sharedData)).start();
    }
}

代码分析：

如上代码，我定义了一个名为SharedData的类，其中包含一个私有的int类型的数据成员data和一个私有的boolean类型的标志成员isReady。还有两个同步方法getData()和setData()。

emsp; 其中getData()方法使用了线程同步，当isReady为false时，使用wait()方法使线程进入等待状态。当isReady为true时，线程被唤醒，并返回data的值。

emsp; setData()方法同样使用了线程同步，它首先将参数value赋值给data，并将isReady设置为true，然后使用notifyAll()方法唤醒所有等待的线程。

emsp; 最后，在main()方法中创建了一个SharedData对象，并创建了两个线程Reader和Writer，分别传入了该SharedData对象作为参数进行操作。

package com.example.javase.ms.threadDemo.day5;

/**
 * @Author ms
 * @Date 2024-04-12 23:01
 */
public class Writer implements Runnable {
    private SharedData sharedData;

    public Writer(SharedData sharedData) {
        this.sharedData = sharedData;
    }

    @Override
    public void run() {
        sharedData.setData(10);
        System.out.println("Writer: " + 10);
    }
}

代码分析：

如上代码，我定义了一个Java线程示例，展示了一个Writer类的实现，实现了Runnable接口。

在构造方法中，传入了一个SharedData对象，表示要写入的共享数据。

在run()方法中，通过调用sharedData对象的setData()方法，将数据设置为10，并且使用System.out.println()打印出消息"Writer: 10"。

该代码的目的是模拟一个写线程，将数据写入共享数据中。

package com.example.javase.ms.threadDemo.day5;

/**
 * @Author ms
 * @Date 2024-04-12 23:00
 */
public class Reader implements Runnable {
    private SharedData sharedData;

    public Reader(SharedData sharedData) {
        this.sharedData = sharedData;
    }

    @Override
    public void run() {
        int data = sharedData.getData();
        System.out.println("Reader: " + data);
    }
}

代码分析：

如上代码，定义了一个名为Reader的类，该类实现了Runnable接口。Reader类有一个成员变量sharedData，它是一个类型为SharedData的对象。

在Reader类的构造函数中，将SharedData对象作为参数传入，并将其赋值给sharedData成员变量。

Reader类实现了Runnable接口的run()方法。在run()方法中，通过调用sharedData对象的getData()方法获取数据，并将其赋值给一个int类型的变量data。然后，通过调用System.out.println()方法将数据打印到控制台。

总的来说，这段代码定义了一个Reader类，用于读取sharedData对象中的数据并输出到控制台。它可以作为一个线程的任务来执行。

小结：

在上述示例中，Reader线程通过调用getData()方法获取数据，如果数据未准备好，则线程将进入等待状态。Writer线程通过调用setData()方法设置数据，并通知Reader线程数据已准备好。通过共享变量和synchronized关键字，Reader和Writer线程实现了基本的线程间通信。

运行结果展示：

根据如上用例，这里我们本地执行一下，结果展示如下：

在这里插入图片描述

应用场景案例

线程间通信在实际开发中有着广泛的应用，下面是一些常见的应用场景案例：

生产者-消费者模型：一个或多个生产者线程生产数据，一个或多个消费者线程消费数据，通过共享队列进行数据交换。
缓存更新：多个线程同时从缓存中获取数据，如果缓存中不存在数据，则需要从数据库中加载数据，并将数据放入缓存。
任务分配：一个任务队列中有多个待执行的任务，多个线程同时从任务队列中取任务执行，可以通过共享队列和互斥锁实现任务的分配和执行。

优缺点分析

线程间通信有以下优点：

提高并发性：线程间通信可以充分利用计算机的多核处理能力，提高系统的并发性和处理速度。
简化编程模型：线程间通信可以简化编程模型，帮助开发者实现复杂的任务分配和协作逻辑。
提高系统可靠性：线程间通信可以帮助开发者实现线程间的同步和互斥，避免数据竞争和死锁等问题。

然而，线程间通信也存在一些缺点：

复杂性：线程间通信涉及到多个线程的协作和数据交换，需要考虑并发和同步等问题，增加了程序的复杂性和调试的难度。
性能开销：线程间通信需要进行线程切换和数据拷贝等操作，会增加系统的性能开销。
容易出错：线程间通信涉及到共享的状态和资源，如果没有正确处理线程间的同步和互斥，会导致数据不一致和程序错误。

因此，在选择线程间通信的方法时，需要根据具体的需求和场景综合考虑各种因素。

类代码方法介绍

以下是SharedData类的方法介绍：

public synchronized int getData(): 获取数据的方法。如果数据未准备好，则线程将进入等待状态，直到数据准备好后返回数据。
public synchronized void setData(int value): 设置数据的方法。设置数据后，通知所有等待中的线程数据已准备好。

Java代码测试用例

测试代码演示

根据如上理论知识，这里我给大家进行一波实例演示，代码如下，仅供参考：

package com.example.javase.ms.threadDemo.day5;

/**
 * @Author ms
 * @Date 2024-04-12 23:06
 */
public class Test {

    public static void main(String[] args) throws InterruptedException {
        SharedData sharedData = new SharedData();
        Thread readerThread = new Thread(new Reader(sharedData));
        Thread writerThread = new Thread(new Writer(sharedData));

        readerThread.start();
        writerThread.start();

        readerThread.join();
        writerThread.join();
    }
}

在上述测试用例中，我们创建了一个SharedData对象，然后分别创建一个Reader线程和一个Writer线程，并启动它们。最后，我们使用join()方法等待两个线程执行完毕。

测试结果展示

根据如上测试用例，这里我们本地执行一下，结果展示如下：

在这里插入图片描述

测试代码分析

根据如上代码作出解析，以便于同学们更好的理解，分析如下：

此段代码是一个多线程编程的示例，其中包含生产者-消费者问题的简化版本。SharedData类模拟了一个共享资源，Reader和Writer类分别模拟消费者和生产者的行为。这段代码没有提供SharedData、Reader和Writer类的实现，但基于命名和上下文，我们可以推测它们的功能。

核心概念

生产者-消费者问题：这是一个经典的多线程同步问题，其中生产者创建数据，消费者处理数据。两者需要共享一个有限的缓冲区（或其他形式的共享资源）。生产者在缓冲区有空间时添加数据，而消费者在缓冲区有数据时取出数据。
线程同步：为了确保生产者和消费者能够正确地共享资源，需要使用同步机制来防止数据竞争和确保数据一致性。

代码逻辑

在main方法中，创建了一个SharedData实例，它代表共享资源。
创建了两个线程：readerThread和writerThread。readerThread执行Reader类的run方法，而writerThread执行Writer类的run方法。
使用start()方法启动这两个线程，使它们并发执行。
使用join()方法等待这两个线程完成。join()方法会阻塞当前线程（在这个例子中是主线程），直到调用join()的线程完成执行。

预期行为

Writer线程会尝试向共享资源中添加数据。
Reader线程会尝试从共享资源中读取数据。
通过适当的同步机制（在提供的代码片段中未显示），Writer和Reader会协调它们的操作，以避免数据竞争和潜在的不一致状态。

注意事项

为了确保线程安全，SharedData类中的方法可能需要使用synchronized关键字或其他同步机制。
Reader和Writer类中的操作可能需要根据共享资源的状态进行等待或通知，这通常通过wait()、notify()或notifyAll()方法实现。
异常处理是多线程程序中的一个重要方面。在这个例子中，主线程捕获了InterruptedException，这是在等待线程完成时可能抛出的异常。

结论

这段代码展示了多线程编程中的一个基本模式，即生产者-消费者问题。为了使程序正确运行，需要确保SharedData、Reader和Writer类实现了适当的同步机制。这样的模式在并发编程中非常常见，它有助于理解如何在多线程环境中管理共享资源。

全文小结

本文介绍了Java多线程编程中的线程间通信的相关知识。我们从简介开始，介绍了线程间通信的基本概念和原理。然后，我们通过源代码解析的方式深入探讨了Java中实现线程间通信的方法。接着，我们给出了一些应用场景案例，展示了线程间通信在实际开发中的应用。随后，我们对线程间通信的优缺点进行了分析，帮助读者了解线程间通信的适用性。

总结

本文全面探讨了Java多线程编程中线程间通信的概念、原理和实现方法。通过介绍Java提供的多种线程通信机制，如共享变量、管道、消息队列、信号量、读写锁和条件，我们了解了如何协调不同线程的执行顺序和数据交换。文章通过具体的代码示例，详细展示了如何使用共享变量和同步方法在线程间进行通信，以及如何通过wait()和notifyAll()方法实现生产者-消费者模型的典型应用。

文章还提供了线程间通信在实际开发中的应用场景案例，如生产者-消费者模型、缓存更新和任务分配等，这些案例说明了线程通信在解决并发问题中的重要作用。同时，对线程通信的优缺点进行了分析，指出了它在提高系统并发性和简化编程模型的同时，也可能增加程序复杂性和性能开销。

最后，文章介绍了SharedData类中的getData()和setData()方法，并通过一个测试用例展示了如何在实际的Java程序中测试线程间通信。通过这些内容，读者可以更深入地理解线程间通信的工作原理，并能够在自己的项目中有效地实现线程间的协作和数据交换。

总结来说，线程间通信是多线程编程中不可或缺的一部分，它使得程序能够更有效地利用多核处理器资源，提高程序的执行效率和响应能力。开发者需要根据具体的应用场景和需求，合理选择和使用Java提供的线程通信机制，以确保程序的正确性和高效性。通过不断学习和实践，开发者可以掌握线程间通信的高级技巧，构建更加健壮和可扩展的多线程应用程序。

… …

文末

好啦，以上就是我这期的全部内容，如果有任何疑问，欢迎下方留言哦，咱们下期见。

… …

学习不分先后，知识不分多少；事无巨细，当以虚心求教；三人行，必有我师焉！！！

wished for you successed ！！！

⭐️若喜欢我，就请关注我叭。

⭐️若对您有用，就请点赞叭。

⭐️若有疑问，就请评论留言告诉我叭。

喵手

关注

20
点赞
踩
25

收藏

觉得还不错? 一键收藏
0
评论
Java零基础之多线程篇：线程间如何通信？

随着计算机技术的发展，多线程编程已经成为现代软件开发中的一个重要方向。在多线程编程中，线程间的通信是一个非常关键的问题。在Java开发语言中，Java提供了一些机制来实现线程间的通信，帮助开发者协调不同线程之间的执行顺序和数据交换。本文将介绍Java多线程编程中的线程间通信的相关知识。首先，我们将从简介开始，介绍线程间通信的基本概念和原理。然后，我们将通过源代码解析的方式，深入探讨Java中实现线程间通信的方法。接着，我们将给出一些应用场景案例，展示线程间通信在实际开发中的应用。
复制链接

扫一扫