Java线程之间如何通信的，有哪些方式？

最新推荐文章于 2025-04-16 11:40:44 发布
最新推荐文章于 2025-04-16 11:40:44 发布
阅读量6.5k 收藏 18
点赞数 8
分类专栏： java 文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Ascend1977/article/details/130932379
版权
本文介绍了Java中线程间通信的主要方式，包括共享变量（需注意线程安全）、锁机制（如synchronized和ReentrantLock）、条件变量、信号量以及管道。通过示例代码展示了如何使用这些机制实现线程间的同步与通信，强调了在实际应用中应考虑线程安全和性能问题。

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

 

线程之间的通信方式主要有以下几种：

  1. 共享变量：线程之间可以通过共享变量来进行通信。不同的线程可以共享同一个变量，并在变量上进行读写操作。需要注意的是，共享变量可能会引发线程安全问题，需要通过同步机制来确保线程安全。

  2. 锁机制：锁机制是一种常用的线程同步机制，可以保证在同一时间只有一个线程能够访问共享资源。Java提供了多种锁类型，如 synchronized 关键字、ReentrantLock 类等。

  3. 条件变量：条件变量是一种线程间通信机制，它用于在一个共享资源上等待某个条件的成立。Java 提供了 Condition 接口来支持条件变量的实现，在使用 Condition 时需要先获取锁，然后调用 await() 方法等待条件成立，当条件成立时可以通过 signal() 或 signalAll() 方法唤醒等待该条件的线程。

  4. 信号量：信号量是一种常见的线程同步机制，可用于控制多个线程对共享资源的访问。Java 提供了 Semaphore 类来实现信号量，Semaphore 类有两个常用的方法 acquire() 和 release()，分别用于获取和释放信号量。

  5. 管道：管道是一种用于线程间通信的高级机制，它可以实现一个线程向另一个线程传送数据。Java 提供了 PipedInputStream 和 PipedOutputStream 两个类来支持管道的实现，其中 PipedInputStream 用于读取数据，PipedOutputStream 用于写入数据。

需要注意的是，以上通信方式都需要在多线程程序中谨慎使用，需要考虑线程安全和性能等方面的问题。为了确保程序正确、高效地运行，需要根据具体情况选择合适的线程通信方式，并进行相应的测试和优化。

具体的示例

共享变量

public class SharedData {
    private int value;
    public synchronized int getValue() { 
        return value; 
    }
    public synchronized void setValue(int value) { 
        this.value = value; 
    }
}

        在这个示例中，定义了一个共享数据类 SharedData，其中包含一个整型变量 value 和两个同步方法 getValue() 和 setValue()，用于获取和设置变量的值。由于这两个方法都是同步的，因此多个线程可以安全地访问该变量。

public class SharedDataExample {
    public static void main(String[] args) throws InterruptedException {
        SharedData sharedData = new SharedData();
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                sharedData.setValue(i);
                System.out.println(Thread.currentThread().getName() + " write " + sharedData.getValue());
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.println(Thread.currentThread().getName() + " read " + sharedData.getValue());
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
    }
}

        在这个示例中，创建了两个线程分别用于读写共享数据 SharedData，多次执行该示例可以看到控制台输出表明两个线程在安全地访问共享变量。

锁机制

public class LockExample {
    private static Lock lock = new ReentrantLock();
    private static int count = 0;
    private static void increase() {
        lock.lock();
        try {
            count++;
        } finally {
            lock.unlock();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                increase();
            }
        });
        Thread thread2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) {
                increase();
            }
        });
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
        System.out.println(count);
    }
}

        在这个示例中，使用了 Lock 接口和 ReentrantLock 类来对计数器进行同步，多次执行该示例可以看到最终输出的计数器值为 20000。

条件变量

public class ConditionExample {
    private static Lock lock = new ReentrantLock();
    private static Condition condition = lock.newCondition();
    private static int count = 0;
    private static void await() throws InterruptedException {
        lock.lock();
        try {
            condition.await();
        } finally {
            lock.unlock();
        }
    }
    private static void signal() {
        lock.lock();
        try {
            condition.signalAll();
        } finally {
            lock.unlock();
        }
    }
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                count++;
                System.out.println(Thread.currentThread().getName() + " increase count to " + count);
                if (count == 5) {
                    signal();
                }
            }
        });
        Thread thread2 = new Thread(() -> {
            try {
                await();
                System.out.println(Thread.currentThread().getName() + " receive signal, count is " + count);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        thread1.start();
        thread2.start();
        thread1.join();
        thread2.join();
    }
}

        在这个示例中，使用了 Lock 接口和 Condition 接口来定义了一个计数器，线程1每次增加计数器的值并判断是否达到条件，当计数器达到条件时调用 signal() 方法通知线程2，线程2等待条件成立后执行相应的操作。


信号量

public class SemaphoreExample {
    private static Semaphore semaphore = new Semaphore(2);
    private static void doWork() throws InterruptedException {
        semaphore.acquire();
        System.out.println(Thread.currentThread().getName() + " start working");
        Thread.sleep(1000);
        System.out.println(Thread.currentThread().getName() + " finish working");
        semaphore.release();
    }
    public static void main(String[] args) throws InterruptedException {
        Thread thread1 = new Thread(() -> {
            try {
                doWork();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread thread2 = new Thread(() -> {
            try {
                doWork();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        Thread thread3 = new Thread(() -> {
            try {
                doWork();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });
        thread1.start();
        thread2.start();
        thread3.start();
        thread1.join();
        thread2.join();
        thread3.join();
    }
}

        在这个示例中，使用了 Semaphore 类来定义了一个信号量，线程1、线程2、线程3都需要获取信号量才能进行工作，每次执行 doWork() 方法需要占用资源，执行完毕后释放信号量。

管道

public class PipeExample {
    static class WriterThread extends Thread {
        private PipedOutputStream output;
        WriterThread(PipedOutputStream output) {
            this.output = output;
        }
        @Override
        public void run() {
            try {
                for(int i=1;i<=10;i++) {
                    output.write(i);
                    System.out.println("写入数据：" + i);
                    Thread.sleep(1000);
                }
            } catch(Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    output.close();
                } catch(Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
    static class ReaderThread extends Thread {
        private PipedInputStream input;
        ReaderThread(PipedInputStream input) {
            this.input = input;
        }
        @Override
        public void run() {
            try {
                int value;
                while((value=input.read()) != -1) {
                    System.out.println("读取数据：" + value);
                }
            } catch(Exception e) {
                e.printStackTrace();
            } finally {
                try {
                    input.close();
                } catch(Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
    public static void main(String[] args) throws IOException {
        PipedOutputStream output = new PipedOutputStream();
        PipedInputStream input = new PipedInputStream(output);
        Thread thread1 = new WriterThread(output);
        Thread thread2 = new ReaderThread(input);
        thread1.start();
        thread2.start();
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

在这个示例中，使用了 PipedOutputStream 类和 PipedInputStream 类来定义了一个管道，线程1向管道中写入数据，线程2从管道中读取数据，通过管道来实现两个线程之间的通信。

JAVA两个线程之间是如何通信的？
xycxycooo的博客
08-07 716
共享变量：通过同步机制保护共享变量的访问，实现线程之间的通信。wait和notifynotifyAll：通过等待和通知机制实现线程之间的通信。Condition接口：提供更灵活的等待和通知机制，通常与一起使用。：通过线程安全的队列实现生产者-消费者模式，实现线程之间的通信。
Java线程之间是如何通信的?
java1234的博客
01-18 1063
Java线程之间是如何通信的?
Java线程之间通信方式
赵广陆
09-09 2465
目录 1 线程之间的通信方式主要有以下几种 2 共享变量 3 锁机制 4 条件变量 5 信号量 6 管道 6 join方法的实现原理 7 join方法实现顺序性原理 1 线程之间的通信方式主要有以下几种 在实际开发时，一个进程中往往有很多个线程，大多数线程之间往往不是绝对独立的，比如说我们需要将A和B 两个线程的执行结果收集在一起然后显示在界面上，又或者比较典型的消费者-生产者模式，在这些场景下，线程间通信成了我们必须使用的手段，那么线程之间怎么通信呢？
Java 多线程核心技术：线程间通信三种经典方式详解与实战
最新发布
异常君的博客
04-16 880
Java 多线程核心技术：线程间通信三种经典方式详解与实战
Java中线程之间是如何通信的
yymagicer的博客
09-20 2599
在 Java 中，线程之间的通信是通过模型来实现的，线程通过共享的对象和变量来交换数据。为了确保线程间通信的正确性，Java 提供了一系列机制来实现线程安全、同步和通信。以下是常用的几种线程间通信的方式，以及它们的使用方法和场景。
【Java进阶】Java线程间通讯的几种方式
热门推荐
不积跬步无以至千里，不积小流无以成江海。一个喜欢学习分享的程序员
11-06 2万+
一、使用同一个共享变量控制 Synchronized、wait、notifyLock、Condition利用volatile利用AtomicInteger二、PipedInputStream、PipedOutputStream 三、利用BlockingQueue
Java里如何实现线程间通信？
djwmzyl的专栏
04-17 3716
正常情况下，每个子线程完成各自的任务就可以结束了。不过有的时候，我们希望多个线程协同工作来完成某个任务，这时就涉及到了线程间通信了。 本文涉及到的知识点：thread.join(), object.wait(), object.notify(), CountdownLatch, CyclicBarrier, FutureTask, Callable 等。 下面我从几个例子作为切入点
Java线程间的通信方式详解
09-02
本文将详细介绍两种常见的Java线程通信方式：同步和while轮询。 1. 同步（Synchronized） 同步是Java中控制线程并发的一种手段，它通过`synchronized`关键字实现。在Java中，同步主要有两种形式：同步方法（通过在...
java 实现线程同步的方式有哪些
09-05
在Java中，有多种方式可以实现线程同步，确保在任何时刻只有一个线程能够访问特定的共享资源。 1. **同步代码块 (Synchronized Block)**: 同步代码块的语法形式如下： ```java synchronized(同一个数据){ // ...
Java面试题：如何在Java中实现线程间的通信？请列举几种常见的方式
杰哥在此的专栏
06-02 564
线程可以通过共享对象的实例变量或方法参数来进行通信。在Java中，线程间的通信主要涉及到线程间的数据交换和协调。这些线程间通信的方式各有特点和适用场景，开发者可以根据具体的应用需求选择合适的通信机制。方法，它们可以用来在线程间进行阻塞和唤醒操作，实现线程间的协调。是一个线程安全的队列，可以用于生产者-消费者模式中的线程间通信。是一个可以在两个线程间交换数据的同步辅助类。接口提供了更高级的锁和条件对象，可以实现复杂的线程间通信。关键字声明的变量可以确保所有线程看到的是最新的值，因为对。
Java - 线程间的通信方式
m0_65228708的博客
12-10 1537
线程通信的方式 共享内存 消息传递 管道输入/输出流
【143期】你知道 Java 是如何实现线程间通信的吗？
良月柒
02-26 320
程序员的成长之路互联网/程序员/技术/资料共享关注阅读本文大概需要 8.5分钟。作者：wingjay来源：http://wingjay.com正常情况下，每个子线程完成各自的任务就可以...
java线程间通讯的几种方式
成都彭于晏
02-04 6140
并发编程中，我们可能会遇到这样一个场景 A、B两个线程并行，但是我希望保证B线程在A线程执行完了后再执行 这个时候就需要线程间进行通讯 A执行完了后对B说一声，喂B，我执行完了 来康康用Java怎么实现 1、基于synchronized 2、基于reentrantLock 3、基于volatile 4、基于countDownLatch 我目前就知道这四种 1、synchronized+wait() 和 notify() wait() 和 notify()都是Object类的通讯方法，注意一点，wai
Java线程间的通信方式
Wdradon的博客
06-27 5537
**定义：**当多个线程共同操作共享的资源时，线程间通过某种方式互相告知自己的状态，以避免无效的资源争夺。通信的方式：**线程同步：**即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作。同步的话，仅仅传递的是控制信息，就是我什么时候运行结束，你什么时候可以来。对于线程间通信来说，线程间同步可以归纳为线程间通信的一个子集，对于线程通信指的是两个线程之间可以交换一些实时的数据信息，而线程同步只交换一些控制信息。在java中有几个关于
Java 如何实现线程间通信
weixin_34252090的博客
09-13 649
正常情况下，每个子线程完成各自的任务就可以结束了。不过有的时候，我们希望多个线程协同工作来完成某个任务，这时就涉及到了线程间通信了。 本文涉及到的知识点： thread.join(), object.wait(), object.notify(), CountdownLatch, CyclicBarrier, FutureTask, ...
Java线程间通信方式剖析——Java进阶（四）
技术世界
06-24 1733
本文将介绍常用的线程间通信工具CountDownLatch、CyclicBarrier和Phaser的用法，并结合实例介绍它们各自的适用场景及相同点和不同点。
JAVA线程之间如何通信
小鲁班-JAVA开发
09-02 232
两种： 1.共享内存（共享内存模型：线程之间共享程序的公共状态，线程之间通过写-读内存中的公共状态来 隐式 进行通信，例如volatile） 2.消息传递（消息传递模型：线程之间没有公共状态，线程之间必须通过明确的发送消息来 显式 进行通信，例如wait和notify） ...
开课吧Java课堂：线程间是如何实现通信
kaikeba的博客
12-07 134
Java对象中隐式管程的应用是很强大的，但是你可以通过进程间通信达到更微妙的境界。这在Java中是尤为简单的。 多线程通过把任务分成离散的和合乎逻辑的单元代替了事件循环程序。线程还有第二优点：它远离了轮询。轮询通常由重复监测条件的循环实现。一旦条件成立，就要采取适当的行动。这浪费了CPU时间。 举例来说，考虑经典的序列问题，当一个线程正在产生数据而另一个程序正在消费它。为使问题变得更有趣，假设数据产生器必须等待消费者完成工作才能产生新的数据。 在轮询系统，消费者在等待生产者产生数据时会浪费很多CPU周期。一
java线程间如何通信
weixin_42608299的博客
02-11 926
Java线程之间可以通过以下方式进行通信： 使用 wait() 和 notify() 方法，这需要使用同步代码块或同步方法。在同步代码块或同步方法中，线程可以调用 wait() 方法阻塞，并在其他线程调用 notify() 方法后恢复执行。 使用 CountDownLatch，它是一个同步辅助类，可以让一个线程等待其他线程的完成。 使用 CyclicBarrier，它也是一个同步辅助类，可以...
线程内有哪些通信方式？线程之间有哪些通信方式？
03-03
<think>嗯，用户问的是线程内和线程之间的通信方式。首先，我需要明确这两个概念的区别。线程内通信可能指的是同一个线程内部的数据传递，而线程间通信则是不同线程之间的数据交换。不过通常来说，线程内通信可能是一个不太常见的说法，因为线程内部的数据处理通常通过局部变量等直接访问，而通信一般指的是不同线程之间的交互。 首先，线程内的通信可能是指线程内部的不同方法或模块之间的数据传递，这时候可能通过局部变量、方法参数、返回值等方式进行。但用户可能更关注的是线程之间的通信方式，这部分需要详细说明。 线程之间的通信方式，常见的有共享内存、消息传递、管道、信号量、互斥锁、条件变量等。共享内存是最常见的方式，线程通过访问共享变量来交换数据，但需要同步机制来避免竞态条件。消息传递可能涉及消息队列，比如生产者-消费者模型中使用队列传递数据。管道可能指的是操作系统提供的管道，但通常用于进程间通信，不过某些编程语言可能有线程间的管道实现。信号量、互斥锁属于同步机制，用于协调线程的执行顺序和访问共享资源。条件变量通常与互斥锁配合使用，让线程在满足特定条件时继续执行。 另外，可能还要区分不同编程语言或框架提供的特定机制，比如Java中的wait/notify，或者Python中的queue模块。需要确保覆盖主要的通信方式，并且正确分类。 需要注意的是，用户可能混淆了线程内和线程间的概念，所以回答时需要明确两者的区别，并分别解释。同时，要避免过于技术化的术语，尽量用通俗易懂的语言说明每种方式的原理和使用场景，可能还需要举例说明，比如共享内存如何配合锁来使用，消息队列如何实现线程间的数据传递等。 最后，要检查信息的准确性，确保提到的每种通信方式都是正确的，并且没有遗漏重要的方法。可能还要考虑用户的实际应用场景，比如多线程编程中常见的同步和通信需求，从而给出实用的建议或最佳实践。</think>### 线程内通信方式（线程内部） 严格来说，线程是程序执行的最小单元，线程内部并不存在传统意义上的“通信”概念，因为线程内的代码是顺序执行的。 但可以通过以下方式在**线程内部**传递数据或控制流程： 1. **局部变量**：通过方法参数传递数据 2. **返回值**：通过方法返回值传递计算结果 3. **异常机制**：通过抛出异常传递错误信息 4. **回调函数**：通过预先定义的回调接口传递处理结果 --- ### 线程间通信方式（跨线程） 当多个线程需要协作时，必须通过特定的同步机制和通信方式保证数据安全。常见的线程间通信方式包括： #### 1. **共享内存（Shared Memory）** - 原理：多个线程访问同一个共享变量或数据结构 - 同步机制： - **互斥锁（Mutex）**：保证同一时间只有一个线程访问临界资源 - **信号量（Semaphore）**：控制对共享资源的访问数量 - **自旋锁（Spinlock）**：忙等待的轻量级锁 - 示例代码（Python）： ```python import threading counter = 0 lock = threading.Lock() def increment(): global counter with lock: counter += 1 ``` #### 2. **消息传递（Message Passing）** - **队列（Queue）**：生产者-消费者模式 - Python的`queue.Queue`是线程安全的实现 - Java的`BlockingQueue`接口 - **管道（Pipe）**：通过操作系统提供的管道通信 - **事件驱动（Event）**：通过事件标志进行状态通知 #### 3. **条件变量（Condition Variable）** - 允许线程在特定条件满足时被唤醒 - 常与互斥锁配合使用 - 示例（Java）： ```java synchronized(lock) { while(!condition) { lock.wait(); // 释放锁并等待 } // 条件满足后执行操作 lock.notifyAll(); // 唤醒其他线程 } ``` #### 4. **原子操作（Atomic Operations）** - 通过硬件支持的原子指令实现无锁编程 - Java的`AtomicInteger`等原子类 - C++的`std::atomic` #### 5. **信号（Signal）** - 通过操作系统信号机制通信（较少用于常规线程通信） --- ### 选择建议 | 场景 | 推荐方式 | |------|----------| | 简单数据共享 | 共享内存 + 互斥锁 | | 生产者-消费者模式 | 消息队列（BlockingQueue） | | 复杂条件等待 | 条件变量（Condition） | | 高性能无锁编程 | 原子操作（Atomic） | 实际开发中应优先考虑高层抽象（如线程池、并发集合），避免直接操作底层同步机制。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值