java八股文面试[多线程]——线程间通信方式

雨点打透心脏的1/2处 2024-03-26 22:17 82阅读 0赞

![253f9ee56567497daba530278e6eba4b.png][]

多个线程在并发执行的时候，他们在CPU中是**随机切换执行**的，这个时候我们想多个线程**一起来完成一件任务**，这个时候我们就需要线程之间的通信了，多个线程一起来完成一个任务，线程通信一般有4种方式：

通过 volatile 关键字  
通过 Object类的 wait/notify 方法  
通过 condition 的 await/signal 方法  
通过 join 的方式

现在有一个问题，两个线程分别打印字符串，但是当线程**A每输出两次**的时候，线程**B就输出一次**，如此反复10次。

###### **通过 volatile 关键字** ######

通过 volatile 关键字来实现这个任务，这个也是最简单的一种实现方式，大致思路 volatile 是共享内存的，**两个线程共享一个标志位**，当标志位**更改的时候就执行不同的线程**。

public class VolatileDemo {
        private static volatile boolean flag = true;  //定义一个标志位，当标志位更改的时候不同的线程被执行
    
        public static void main(String[] args) {
            //线程A启动
            new Thread(() -> {
                int i = 0;
                while(true){  //进行死循环，一直输出语句
                    if (flag){  //对标志位的判断，符合就执行
                        System.out.println(Thread.currentThread().getName()+" ===>" + ++i); //输出语句
                        if (i%2==0){  //如果语句输出两次了 改变标志位
                            flag  =false;
                        }
                        if (i == 10) break;  //到达十次，结束循环
                    }
                }
            }, "A").start();
            new Thread(() -> {
                int i = 0;
                while(true){
                    if (!flag){  //判断条件不一样
                        System.out.println(Thread.currentThread().getName()+" 被唤醒啦 " + ++i);
                        flag  = true;  //改变标志位
                        if (i == 5) break;
                    }
                }
            }, "B").start();
        }
    }

![02d84c15304e4d029abd4272e3b983d2.png][]

我们发现我们这个位置用的**while循环**的，用for循环指定次数可以吗，是不可以的，因为我们只是**改变了标志位**，但是并没有**立刻唤醒**另外一个线程让他执行，虽然我打印的语句是我被唤醒了，但是实际上只是线程**A处于死循环**，啥子也不做，直到线程**B抢到了时间片**，进行对标志位的判断，然后输出语句，在进行空循环，等待A抢到时间片，如此反复，可以自己在if判断外面加一条计数语句，来验证一下结果，如果想要**立刻唤醒**的话，那么就是另外一种方法啦。

###### **通过 Object类的 wait/notify 方法** ######

对于上面的volatile关键字这个方法来说，我们的线程执行了**很多次空循环**，来等待另外一个线程来获取锁，这种操作无疑是十分**消耗CPU的资源**的，所以说为了解决这种情况，我们就需要一种机制可以实现线程之间的通信，可以唤醒其他的线程，而不是等待直到自己获取CPU的时间片，我们都知道，Object类提供了三个线程间通信的方法，wait()，notify()，notifyAll()。**这三个方法必须都在同步代码块中执行的**。

<table> 
 <thead> 
  <tr> 
   <th>方法名</th> 
   <th>具体操作</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>wait()</td> 
   <td>wait()方法执行前，是必<strong>须要获得对应的锁</strong>的，当执行wait()方法后，线程就会释放掉自己所占有的锁，释放CPU，然后进入阻塞状态，直到被notify()方法唤醒。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>notify()</td> 
   <td>会唤醒一个处于等待该<strong>对象锁</strong>的线程，然后继续往下执行，直到执行完退出对象锁锁住的区域（synchronized修饰的代码块）后再释放锁。</td> 
  </tr> 
 </tbody> 
</table>

<table> 
 <tbody> 
  <tr> 
   <td>notifyAll()</td> 
   <td>和notify()方法差不多，只不过他是唤醒<strong>所有</strong>等待该对象锁的线程，让他们进入就绪队列，但是谁执行就看谁抢占到CPU，notify()方法也是这样，只不过是唤醒随机的一个而已</td> 
  </tr> 
 </tbody> 
</table>

每个锁对象都有两个队列，一个是**就绪队列**，一个是**阻塞队列**。就绪队列存储了已就绪（将要竞争锁）的线程，阻塞队列存储了被阻塞的线程。当一个阻塞线程被唤醒后，才会进入就绪队列，进而等待CPU的调度；反之，当一个线程被wait后，就会进入阻塞队列，等待被唤醒。

public class WaitAndNotify {
        public static void main(String[] args) {
            Object lock = new Object();  //创建一个锁对象
            new Thread(() -> {
                for (int i = 1; i <= 10; i++) {
                    synchronized (lock) {  //首先需要获取锁
                        System.out.println(Thread.currentThread().getName() + " ==> " + i);
                        if (i % 2 == 0) {
                            lock.notify();  //唤醒线程B
                            if (i!=10){
                                try {
                                    lock.wait();  //让自己等待
                                } catch (InterruptedException e) {
                                    e.printStackTrace();
                                }
                            }
                        }
                    }
                }
            }, "A").start();
            new Thread(() -> {
                for (int i = 1; i <= 5; i++) {
                    synchronized (lock) {
                        lock.notify();  //我们看到，执行notify方法时，后面的代码还是执行了，并不是立刻释放资源
                        System.out.println(Thread.currentThread().getName() + "我执行了notify方法 " + i);
                        if (i!=5){
                            try {
                                lock.wait();
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                }
            }, "B").start();
        }
    }

![b72d606c072a468eb024efb59424f526.png][]

通过上面的代码我们发现，当执行**notify方法时，我们并不会立刻释放锁资源**，而是在执行完我们**代码块里面的内容时**才会释放掉锁资源，而**wait()方法则会立刻释放掉锁资源，进入阻塞状态**，这里我们有举例子，可以自己在wait()方法后面加上一个输出语句。我们进行**交替通信**的规则就是，执行wait(）方法，释放掉锁资源，然后执行 notify() 方法，唤醒其他的线程，在代码中，我在wait()方法上加了一个判断，如果是**最后一次**的话，那么我就不执行，为什么，因为我在执行wait()方法的时候，那么线程除非被唤醒，**否则就会一直阻塞**，这样的话我们的demo就不可以结束了，一直处于允许状态。

###### 通过 condition 的 await/signal 方法 ######

Condiction对象是通过**lock对象**来创建得(调用lock对象的**newCondition**()方法)，他在使用前也是需要获取锁得，其中，Lock 替代了 synchronized 方法和语句的使用，Condition **替代了 Object** 监视器方法的使用。Condiction对象得常用方法：

**await**() : 线程自主释放锁，进入沉睡状态，直到被再次唤醒。  
await(long time, TimeUnit unit) ：线程自主释放锁，进入沉睡状态，被唤醒或者未到达等待时间时一直处于等待状态。  
signal()： 唤醒一个等待线程。  
signal()All() ：唤醒所有等待线程,能够从等待方法返回的线程必须获得与Condition相关的锁。

public static void main(String[] args) {
            //设置一个锁
            Lock lock = new ReentrantLock();
            Condition condition = lock.newCondition();
            AtomicInteger number = new AtomicInteger(1);
            AtomicInteger count = new AtomicInteger(1);
            new Thread(()->{
                while (count.get() != 10){
                    lock.lock();
                    try {
                        count.getAndIncrement();
                        if (number.get() != 1 && count.get() != 11){
                            condition.await();
                        }
                        number.getAndIncrement();
                        System.out.println(Thread.currentThread().getName() + "---> 生产");
                        condition.signalAll();
                    }catch (Exception e){
                        e.printStackTrace();
                    }finally {
                        lock.unlock();
                    }
                }
            },"producter").start();
            new Thread(()->{
                while (count.get() != 10 ){
                    lock.lock();
                    try {
                        count.getAndIncrement();
                        if (number.get() != 2 && count.get() != 11){
                            condition.await();
                        }
                        number.getAndDecrement();
                        System.out.println(Thread.currentThread().getName() + "---> 消费");
                        condition.signalAll();
                    }catch (Exception e){
                        e.printStackTrace();
                    }finally {
                        lock.unlock();
                    }
                }
            },"customer").start();
        }

![98e65de1219a49a38b336170c7cd2c02.png][]

await操作会立刻释放掉锁，进入阻塞状态，singal会唤醒等待队列中的**头节点(失败就依次唤醒)**。这个代码逻辑有大问题，只是这样写看得出数据之间的交换即可。注意点：代码一定要**在lock和unlock之间**。

###### 通过 join 方法来实现线程通信 ######

public static void main(String[] args) throws InterruptedException {
            Thread A = new Thread(() -> {
                System.out.println("执行完毕");
            },"A");
            Thread B = new Thread(()->{
                try {
                    Thread.sleep(1000L);
                    System.out.println(Thread.currentThread().getName() + "测试join");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                },"B");
            A.start();
            B.start();
            B.join();
            System.out.println("Main线程");
        }

![78db1c87d3a244fd868a6a0606454b05.png][]

简单来说，就是join方法会让自己提前执行，比如上面的例子中就是让Main线程阻塞了，等待B线程执行完毕后才会执行。本质就是调用了wait方法，让当前线程阻塞，直到另一个线程执行完毕。(当前线程wait后，执行join方法的线程大概率抢到锁资源，而且当一个线程执行完毕后，会默认调用notifyAll方法。)

**小结**  
其实准确来说，应该只有三种可以通信的方式，join只是让当前线程**先执行完**，并没有说根据两个线程之间**数据的共享**。

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

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

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

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

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

**管道**：管道是一种用于线程间通信的高级机制，它可以实现一个线程向另一个线程传送数据。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 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();
            }
        }
    }

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

知识来源：

[【23版面试突击】 在Java中线程间有哪些通信方式？\_哔哩哔哩\_bilibili][23_ _Java_bilibili]

[线程通信的四种方式\_我是哎呀呀的博客-CSDN博客][-CSDN]

[Java线程之间如何通信的，有哪些方式？\_java线程间通信的几种方法\_Ascend1797的博客-CSDN博客][Java_java_Ascend1797_-CSDN]

[253f9ee56567497daba530278e6eba4b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/f6a473ac3c3a4a349803bc4a0fbf2fe0.png
[02d84c15304e4d029abd4272e3b983d2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/43d7abb74d5d44a7be2b4cfd69c1406c.png
[b72d606c072a468eb024efb59424f526.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/773de91d3ba44ca0b60ba83114ac6d18.png
[98e65de1219a49a38b336170c7cd2c02.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/b257ba414f864d95b56af572ad40f457.png
[78db1c87d3a244fd868a6a0606454b05.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/13/368328cb7aaa47aab44c01933268e52a.png
[23_ _Java_bilibili]: https://www.bilibili.com/video/BV1M24y1z7BR?p=143&vd_source=7ec3a2ec18181a9b64c9a3246305e511
[-CSDN]: https://blog.csdn.net/weixin_43786099/article/details/119945831
[Java_java_Ascend1797_-CSDN]: https://blog.csdn.net/Ascend1977/article/details/130932379