深入理解Java线程间通信

最新推荐文章于 2024-09-26 03:16:28 发布
最新推荐文章于 2024-09-26 03:16:28 发布
阅读量1k 收藏
点赞数
文章标签： java jvm 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/BASK2311/article/details/128032039
版权

合理的使用Java多线程可以更好地利用服务器资源。一般来讲，线程内部有自己私有的线程上下文，互不干扰。但是当我们需要多个线程之间相互协作的时候，就需要我们掌握Java线程的通信方式。本文将介绍Java线程之间的几种通信原理。

锁与同步

在Java中，锁的概念都是基于对象的，所以我们又经常称它为对象锁。一个锁同一时间只能被一个线程持有。也就是说，一个锁如果被一个线程所持有，那其他线程如果需要得到这个锁，就得等这个线程释放该锁。

线程之间，有一个同步的概念。在多线程中，可能有多个线程试图访问一个有限的资源，必须预防这种情况的发生。

所以引入了同步机制：在线程使用一个资源时为其加锁，这样其他的线程便不能访问那个资源了，直到解锁后才可以访问。线程同步是线程之间按照一定的顺序执行。

我们先来看看一个无锁的程序：

public class NoLock {

    static class ThreadA implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println("Thread A " + i);
            }
        }
    }

    static class ThreadB implements Runnable {
        @Override
        public void run() {
            for (int i = 0; i < 100; i++) {
                System.out.println("Thread B " + i);
            }
        }
    }

    public static void main(String[] args) {
        new Thread(new ThreadA()).start();
        new Thread(new ThreadB()).start();
    }
}
复制代码

执行这个程序，你会在控制台看到，线程A和线程B各自独立工作，输出自己的打印值。每一次运行结果都会不一样。如下是我的电脑上某一次运行的结果。

...
Thread B 74
Thread B 75
Thread B 76
Thread B 77
Thread B 78
Thread B 79
Thread B 80
Thread A 3
Thread A 4
Thread A 5
Thread A 6
Thread A 7
Thread A 8
Thread A 9
...
复制代码

现在有一个需求，想等A先执行完之后，再由B去执行，怎么办呢？最简单的方式就是使用一个“对象锁”。

public class ObjLock {

    private static Object lock = new Object();

    static class ThreadA implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                for (int i = 0; i < 100; i++) {
                    System.out.println("Thread A " + i);
                }
            }
        }
    }

    static class ThreadB implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                for (int i = 0; i < 100; i++) {
                    System.out.println("Thread B " + i);
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new Thread(new ThreadA()).start();
        Thread.sleep(10);
        new Thread(new ThreadB()).start();
    }
}
复制代码

这里声明了一个名字为lock的对象锁。我们在ThreadA和ThreadB内需要同步的代码块里，都是用synchronized关键字加上了同一个对象锁lock。

上文我们说到了，根据线程和锁的关系，同一时间只有一个线程持有一个锁，那么线程B就会等线程A执行完成后释放lock，线程B才能获得锁lock。

这里在主线程里使用sleep方法睡眠了10毫秒，是为了防止线程B先得到锁。因为如果同时start，线程A和线程B都是出于就绪状态，操作系统可能会先让B运行。这样就会先输出B的内容，然后B执行完成之后自动释放锁，线程A再执行。

等待/通知机制

上面一种基于“锁”的方式，线程需要不断地去尝试获得锁，如果失败了，再继续尝试。这可能会耗费服务器资源。 而等待/通知机制是另一种方式。

Java多线程的等待/通知机制是基于Object类的wait()方法和notify(), notifyAll()方法来实现的。

notify()方法会随机叫醒一个正在等待的线程，而notifyAll()会叫醒所有正在等待的线程。

前面我们讲到，一个锁同一时刻只能被一个线程持有。而假如线程A现在持有了一个锁lock并开始执行，它可以使用lock.wait()让自己进入等待状态。这个时候，lock这个锁是被释放了的。

这时，线程B获得了lock这个锁并开始执行，它可以在某一时刻，使用lock.notify()，通知之前持有lock锁并进入等待状态的线程A，说“线程A你不用等了，可以往下执行了”。

需要注意的是，这个时候线程B并没有释放锁lock，除非线程B这个时候使用lock.wait()释放锁，或者线程B执行结束自行释放锁，线程A才能得到lock锁。

用代码来实现一下：

public class WaitNotify {

    private static Object lock = new Object();

    static class ThreadA implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                for (int i = 0; i < 5; i++) {
                    try {
                        System.out.println("ThreadA: " + i);
                        lock.notify();
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                lock.notify();
            }
        }
    }

    static class ThreadB implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                for (int i = 0; i < 5; i++) {
                    try {
                        System.out.println("ThreadB: " + i);
                        lock.notify();
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                lock.notify();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new Thread(new ThreadA()).start();
        Thread.sleep(1000);
        new Thread(new ThreadB()).start();
    }
}

// 输出：
ThreadA: 0
ThreadB: 0
ThreadA: 1
ThreadB: 1
ThreadA: 2
ThreadB: 2
ThreadA: 3
ThreadB: 3
ThreadA: 4
ThreadB: 4
复制代码

线程A和线程B首先打印出自己需要的东西，然后使用notify()方法叫醒另一个正在等待的线程，然后自己使用wait()方法陷入等待并释放lock锁。

需要注意的是等待/通知机制使用的是使用同一个对象锁，如果你两个线程使用的是不同的对象锁，那它们之间是不能用等待/通知机制通信的。

信号量--Volatile

信号量(Semaphore) ：有时被称为信号灯，是在多线程环境下使用的一种设施，是可以用来保证两个或多个关键代码段不被并发调用。在进入一个关键代码段之前，线程必须获取一个信号量；一旦该关键代码段完成了，那么该线程必须释放信号量。其它想进入该关键代码段的线程必须等待直到第一个线程释放信号量。

本文不是要介绍这个类，而是介绍一种基于volatile关键字的自己实现的信号量通信。

volatile关键字能够保证内存的可见性，如果用volatile关键字声明了一个变量，在一个线程里面改变了这个变量的值，那其它线程是立马可见更改后的值的。

比如我现在有一个需求，我想让线程A输出0，然后线程B输出1，再然后线程A输出2…以此类推。我应该怎样实现呢？

public class Count {
    private static volatile int count = 0;

    static class ThreadA implements Runnable {
        @Override
        public void run() {
            while (count < 5) {
                if (count % 2 == 0) {
                    System.out.println("threadA: " + count);
                    synchronized (this) {
                        count++;
                    }
                }
            }
        }
    }

    static class ThreadB implements Runnable {
        @Override
        public void run() {
            while (count < 5) {
                if (count % 2 == 1) {
                    System.out.println("threadB: " + signal);
                    synchronized (this) {
                        count++;
                    }
                }
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        new Thread(new ThreadA()).start();
        Thread.sleep(1000);
        new Thread(new ThreadB()).start();
    }
}

// 输出：
threadA: 0
threadB: 1
threadA: 2
threadB: 3
threadA: 4
复制代码

我们可以看到，使用了一个volatile变量count来实现了“信号量”的模型。这里需要注意的是，volatile变量需要进行原子操作，而count++并不是一个原子操作，根据需要使用synchronized给它“上锁”，或者是使用AtomicInteger等原子类。

信号量的应用场景

假如在一个停车场中，车位是我们的公共资源，线程就如同车辆，而看门的管理员就是起的“信号量”的作用。 因为在这种场景下，多个线程需要相互合作，我们用简单的“锁”和“等待通知机制”就不那么方便了。这个时候就可以用到信号量。

管道输入/输出流

管道是基于“管道流”的通信方式。JDK提供了PipedWriter、 PipedReader、 PipedOutputStream、 PipedInputStream。

其中，前面两个是基于字符的，后面两个是基于字节流的。

以下示例代码使用的是基于字符的：

public class Pipe {
    static class ReaderThread implements Runnable {
        private PipedReader reader;

        public ReaderThread(PipedReader reader) {
            this.reader = reader;
        }

        @Override
        public void run() {
            System.out.println("this is reader");
            int receive = 0;
            try {
                while ((receive = reader.read()) != -1) {
                    System.out.print((char)receive);
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    static class WriterThread implements Runnable {

        private PipedWriter writer;

        public WriterThread(PipedWriter writer) {
            this.writer = writer;
        }

        @Override
        public void run() {
            System.out.println("this is writer");
            int receive = 0;
            try {
                writer.write("test");
            } catch (IOException e) {
                e.printStackTrace();
            } finally {
                try {
                    writer.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    public static void main(String[] args) throws IOException, InterruptedException {
        PipedWriter writer = new PipedWriter();
        PipedReader reader = new PipedReader();
        writer.connect(reader);

        new Thread(new ReaderThread(reader)).start();
        Thread.sleep(1000);
        new Thread(new WriterThread(writer)).start();
    }
}

// 输出：
this is reader
this is writer
test
复制代码

我们通过线程的构造函数，传入了PipedWrite和PipedReader对象。可以简单分析一下这个示例代码的执行流程：

  1. 线程ReaderThread开始执行，
  2. 线程ReaderThread使用管道reader.read()进入”阻塞“，
  3. 线程WriterThread开始执行，
  4. 线程WriterThread用writer.write("test")往管道写入字符串，
  5. 线程WriterThread使用writer.close()结束管道写入，并执行完毕，
  6. 线程ReaderThread接受到管道输出的字符串并打印，
  7. 线程ReaderThread执行完毕。

管道通信的应用场景

这个很好理解。使用管道多半与I/O流相关。当我们一个线程需要先另一个线程发送一个信息（比如字符串）或者文件等等时，就需要使用管道通信了。

Thread.join()方法

join()方法是Thread类的一个实例方法。它的作用是让当前线程陷入“等待”状态，等join的这个线程执行完成后，再继续执行当前线程。

有时候，主线程创建并启动了子线程，如果子线程中需要进行大量的耗时运算，主线程往往将早于子线程结束之前结束。

如果主线程想等待子线程执行完毕后，获得子线程中的处理完的某个数据，就要用到join方法了。

示例代码：

public class Join {
    static class ThreadA implements Runnable {

        @Override
        public void run() {
            try {
                System.out.println("我是子线程，我先睡一秒");
                Thread.sleep(1000);
                System.out.println("我是子线程，我睡完了一秒");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(new ThreadA());
        thread.start();
        thread.join();
        System.out.println("如果不加join方法，我会先被打出来，加了就不一样了");
    }
}
复制代码

ThreadLocal类

ThreadLocal是一个本地线程副本变量工具类。内部是一个弱引用的Map来维护。

严格来说，ThreadLocal类并不属于多线程间的通信，而是让每个线程有自己”独立“的变量，线程之间互不影响。它为每个线程都创建一个副本，每个线程可以访问自己内部的副本变量。

ThreadLocal类最常用的就是set方法和get方法。示例代码：

public class Profiler {

    private static final ThreadLocal<Long> TIME_THREADLOCAL = new ThreadLocal<Long>() {
        protected Long initialValue() {
            return System.currentTimeMillis();
        }
    };

    public static void begin() {
        TIME_THREADLOCAL.set(System.currentTimeMillis());
    }

    public static long end() {
        return System.currentTimeMillis() - TIME_THREADLOCAL.get();
    }

    public static void main(String[] args) throws InterruptedException {
        Profiler.begin();
        TimeUnit.SECONDS.sleep(1);
        System.out.println("耗时：" + Profiler.end() + "mills");
    }
}

// 输出：
耗时：1001mills
复制代码

Profiler 可以被复用在方法的耗时统计的功能上，在方法的入口前执行begin()方法，在方法调用后执行end()方法，好处是两个方法的调用不用在一个方法和类中，比如在AOP（面向切面编程）中，可以在方法调用前的切入点执行begin()方法，而在方法调用切入点执行end()方法，这样依旧可以获得方法的执行耗时。

ThreadLocal的应用场景

最常见的ThreadLocal使用场景为用来解决数据库连接、Session管理等。数据库连接和Session管理涉及多个复杂对象的初始化和关闭。如果在每个线程中声明一些私有变量来进行操作，那这个线程就变得不那么“轻量”了，需要频繁的创建和关闭连接。

小结

线程间通信使线程成为一个整体，提高系统之间的交互性，在提高CPU利用率的同时可以对线程任务进行有效的把控与监督。

 

「已注销」
关注
深入理解JAVA多线程之线程间的通信方式
09-02
本文将深入探讨两种主要的线程间通信方式：同步机制和基于轮询的方式。 1. 同步机制： Java中的同步机制主要是通过`synchronized`关键字来实现的，它提供了互斥访问，即在同一时刻只有一个线程可以执行特定的代码...
Java线程之间如何通信的，有哪些方式？
Ascend1977的博客
05-29 6205
尽可能避免共享变量，因为共享变量容易引起线程安全问题。对共享变量的访问需要加锁，以保证同步访问。避免死锁问题的发生。使用锁时需要特别注意加锁和释放锁的顺序。使用条件变量时，应该确保线程在调用 await() 方法之前已经获取了锁。否则，在等待条件成立的过程中，其他线程可能会修改共享资源，导致程序出现错误。 在使用信号量时，需要正确设置信号量的个数和调用 acquire() 和 release() 方法的顺序，否则可能会出现线程阻塞或信号量无法释放的情况。管道的使用需要注意线程之间的数据传输方式，以及缓冲区的
Java线程间通信方式
小海编码日记
04-24 1295
前文了解了线程的创建方式和状态切换，在实际开发时，一个进程中往往有很多个线程，大多数线程之间往往不是绝对独立的，比如说我们需要将A和B 两个线程的执行结果收集在一起然后显示在界面上，又或者比较典型的消费者-生产者模式，在这些场景下，线程间通信成了我们必须使用的手段，那么线程之间怎么通信呢？线程间通信方式，从实现本质来讲，主要可以分为两大类共享内存和消息传递。
【Java】—— 多线程：线程间的通信机制与生产者消费者案例
最新发布
weixin_63106307的博客
09-26 1104
要解决该问题，就必须让生产者线程在缓冲区满时等待(wait)，暂停进入阻塞状态，等到下次消费者消耗了缓冲区中的数据的时候，通知(notify)正在等待的线程恢复到就绪状态，重新开始往缓冲区添加数据。比如：线程A用来生产包子的，线程B用来吃包子的，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，此时B线程必须等到A线程完成后才能执行，那么线程A与线程B之间就需要线程通信，即——在有多个线程进行等待时，如果需要，可以使用。，比如去争夺锁，但这并不是故事的全部，线程间也会有协作机制。
Java并发学习 7: 线程之间的通信
过道
04-10 2873
3.1 继承 Thread类 // 继承，则Demo1 也成为了一个线程 public class Demo1 extends Thread { // 继承Thread类，需要重写run()方法，告诉这个类需要去坐什么. @Override public void run() { // 这个新类，只需要打印出自己的名字(每个线程都有自己的Name属性并提供g...
Java线程之间通信方式
赵广陆
09-09 2313
目录 1 线程之间的通信方式主要有以下几种 2 共享变量 3 锁机制 4 条件变量 5 信号量 6 管道 6 join方法的实现原理 7 join方法实现顺序性原理 1 线程之间的通信方式主要有以下几种 在实际开发时，一个进程中往往有很多个线程，大多数线程之间往往不是绝对独立的，比如说我们需要将A和B 两个线程的执行结果收集在一起然后显示在界面上，又或者比较典型的消费者-生产者模式，在这些场景下，线程间通信成了我们必须使用的手段，那么线程之间怎么通信呢？
java线程间如何通信
weixin_42608299的博客
02-11 899
Java线程之间可以通过以下方式进行通信： 使用 wait() 和 notify() 方法，这需要使用同步代码块或同步方法。在同步代码块或同步方法中，线程可以调用 wait() 方法阻塞，并在其他线程调用 notify() 方法后恢复执行。 使用 CountDownLatch，它是一个同步辅助类，可以让一个线程等待其他线程的完成。 使用 CyclicBarrier，它也是一个同步辅助类，可以...
深入理解Java 线程通信
08-19
"深入理解Java 线程通信" Java 线程通信是指在 Java 编程语言中，多个线程之间如何进行交流和协作的机制。Java 提供了多种机制来实现线程间的通信，包括使用 wait()、notify() 和 notifyAll() 方法，使用同步锁和 ...
深入解析Java的线程同步以及线程间通信
09-03
总之，Java的线程同步和线程间通信是多线程编程中的关键概念，通过`synchronized`关键字、同步块和监视器锁，以及`wait()`, `notify()`, `notifyAll()`等方法，可以有效地管理共享资源，避免并发问题，并实现线程间...
Java线程间通信不同步问题原理与模拟实例
08-25
Java线程间通信是多线程编程中的重要概念，它涉及到如何在多个并发执行的线程之间有效地共享数据。在Java中，线程间的通信主要目的是解决资源共享时可能出现的竞态条件、死锁等问题，确保数据的一致性和完整性。本文...
深入Android Handler与线程间通信ITC的详解
09-05
这篇文章将深入探讨Android Handler与线程间通信ITC的工作原理及其应用。 首先，理解Handler的作用。Handler主要用于操作线程内部的消息队列，它能够发送和处理Message对象。在Android系统中，主线程（UI线程）默认...
Java线程间的通信方式
Wdradon的博客
06-27 5410
**定义：**当多个线程共同操作共享的资源时，线程间通过某种方式互相告知自己的状态，以避免无效的资源争夺。通信的方式：**线程同步：**即当有一个线程在对内存进行操作时，其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作。同步的话，仅仅传递的是控制信息，就是我什么时候运行结束，你什么时候可以来。对于线程间通信来说，线程间同步可以归纳为线程间通信的一个子集，对于线程通信指的是两个线程之间可以交换一些实时的数据信息，而线程同步只交换一些控制信息。在java中有几个关于
Java中的线程通信详解
weixin_42303107的博客
07-14 487
Java中的线程通信详解 大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！ 在多线程编程中，线程之间的通信是一个重要且复杂的主题。为了确保多线程程序的正确性和效率，线程需要能够互相通信并协调工作。Java 提供了多种方式来实现线程间的通信，如 wait()、notify()、notifyAll...
Java多线程--线程间的通信
人生得意须尽欢
02-02 1778
Java多线程--线程间的通信
Java中的线程通信的几种方式
u013749113的博客
05-17 1619
Java中提供了多种方式来实现线程间通信，其中最常见的方式包括synchronized关键字、wait()和notify()方法、CountDownLatch类、Semaphore类和BlockingQueue类。这些方式都可以用来实现线程之间的互斥、同步、数据共享和通信。选择哪种方式取决于具体的应用场景和需求。在使用这些方式时，需要注意线程安全和死锁等问题，以确保程序的正确性和健壮性。
【Java 基础篇】Java 线程通信详解
繁依Fanyi的博客
09-20 784
线程通信是指多个线程之间通过共享内存或其他通信机制来传递信息、同步动作或协作完成任务的过程。线程通信的核心目标是确保线程能够按照预定的顺序执行，并且能够安全地访问共享资源。线程同步：确保多个线程之间的操作按照一定的顺序执行，避免竞态条件和数据不一致性问题。线程等待：使线程能够等待某个条件的满足，以便在条件满足时再继续执行。线程通知：使线程能够通知其他线程某个条件已经满足，以便其他线程可以继续执行。线程唤醒：使等待状态的线程被唤醒，以便它们可以继续执行。
Java线程之间如何通信
baidu_41638844的博客
06-03 1011
可以通过Lock对象的newCondition()方法获取一个Condition实例，然后线程可以调用await()方法进入等待状态，直到其他线程调用signal()或signalAll()方法来唤醒它们。：Java提供了Object类的wait()、notify()和notifyAll()方法来实现线程之间的等待和通知。线程可以调用wait()方法进入等待状态，直到其他线程调用notify()或notifyAll()方法唤醒它。这些方法提供了不同的线程通信机制，具体使用哪种方式取决于你的需求和场景。
【多线程】Java线程间通信
DreamSun的博客
05-23 1302
线程间通信使线程成为一个整体，提高系统之间的交互性，在提高CPU利用率的同时可以对线程任务进行有效的把控与监督。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值