Java 多线程-多线程通信

一时失言乱红尘 2022-10-23 12:54 271阅读 0赞

最近，美美非常的爱吃栗子，剥栗子却有些麻烦，这个任务理所当然的交给了帅帅，每一次，帅帅都会把热气腾腾的栗子剥好，然后放进一个盘子里，而美美每次都会从盘子里拿一个栗子吃：  
![在这里插入图片描述][20210305170246896.png]

我们来模拟一下这个情况，首先，我们定义一个盘子，用来存放我们的栗子：

/** * 定义一个盘子 */
    class Plate { 
    
        // 栗子存储的空间
        private int[] cells = new int[10];
    
        // inPos表示存入的时候数组的下标，outPos表示取出的时候数组的下标
        private int inPos;
        private int outPos;
    
        // 定义一个put()方法向盘子中放栗子
        public void put(int num) { 
            cells[inPos] = num;
            System.out.println("在cells[" + inPos + "]中放入了一个栗子----" + cells[inPos]);
            // 存完元素让位置+1
            inPos++;
            //当inPos为数组长度的时候，将其置为0
            if (inPos == cells.length) { 
                inPos = 0;
            }
        }
    
        /** * 定义一个get()方法从盘子中取出栗子 */
        public void get() { 
            int data = cells[outPos];
            System.out.println("从cells[" + outPos + "]中取出了一个栗子" + data);
            // 取完后元素位置+1
            outPos++;
            if (outPos == cells.length) { 
                outPos = 0;
            }
        }
    
    }

上面，我们定义了一个盘子，cells来存放数据（栗子），put方法用来向盘子中存放栗子，get 方法用于从盘子中获取数据。

针对数组元素的存取操作都是从第一个元素开始依次进行的，每当操作完数组的最后一个元素时，索引都会被置为0，也就是重新从数组的第一个位置开始存取元素。

接下来我们实现两个线程用来模拟两个人的操作，这两个线程都需要实现Runnable接口：

/** * 帅帅类，剥栗子者也 */
    class ShuaiShuai implements Runnable { 
    
        private Plate plate;
        // 定义一个变量num
        private int num;
    
        // 通过构造方法来接受一个盘子对象
        public ShuaiShuai(Plate plate) { 
            this.plate = plate;
        }
    
        @Override
        public void run() { 
            while (true) { 
                // 将num存入数组，每次存入后num自增
                plate.put(num++);
            }
        }
    }
    
    /** * 美美类，吃栗子者也 */
    class MeiMei implements Runnable { 
    
        private Plate plate;
    
        // 通过构造方法接收一个Plate对象
        MeiMei(Plate plate) { 
            this.plate = plate;
        }
    
        @Override
        public void run() { 
            while (true) { 
                // 循环取出元素
                plate.get();
            }
        }
    }

上面的两个类，都实现了Runnable接口，并且构造方法中都接收了一个Plate类型的对象。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70]  
在帅帅的类ShuaiShuai中的run方法使用while循环不断的向存储空间中存放数据num，并且每次存入数据后将num进行自增，从而实现栗子1，栗子2，栗子3的效果。  
在美美的类MeiMei中的run方法使用while循环不停的从存储空间中取出数据。

接下来我们写一个测试程序，开启两个线程分别运行MeiMei类和ShuaiShuai类中的代码，如下所示：

public class Demo { 
        public static void main(String[] args) { 
    
            // 创建一个盘子
            Plate plate = new Plate();
    
            // 创建帅帅对象和美美对象，并将盘子传入
            ShuaiShuai shuaiShuai = new ShuaiShuai(plate);
            MeiMei meiMei = new MeiMei(plate);
    
            // 开启两个线程
            new Thread(shuaiShuai).start();
            new Thread(meiMei).start();
    
        }
    }

我们运行一下，发现了一个问题：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 1]  
首先是当帅帅把栗子放入盘子中的时候，存在一个循环放置的问题，还没等美美将盘子拿走，已经将栗子又放了一遍，就覆盖掉了原来的栗子（好吧，这里暂且忽略它的荒谬）；  
其次，美美取出的时候，也是循环取出的，其实栗子已经拿出来了，但是还是又在同样的位置又拿了一遍（也忽略此处的荒谬性），这样就拿了一个寂寞；  
而且，每次帅帅都是放入了一段时间了，美美才拿出的，热气腾腾的例子可能都放凉了（我们是模拟，现实中不可能帅帅几秒钟就剥了5万多个例子的，美美也不可能吃那么快，哈哈哈），可能会吃坏肚子。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 2]  
**如何解决这个问题呢？**

通过前面的学习，我们知道可以通过锁来解决这个问题。  
而我们想要控制多个线程按照一定的顺序轮流执行，这个时候就需要让线程间进行通信。

在object类中提供了`wait()`、`notify()`、`notifyAll()`方法用于解决线程间的通信问题，由于Java中所有类都是Object类的子类或者间接子类，因此任何类的实例对象都可以直接使用这些方法。

唤醒线程的方法：

<table> 
 <thead> 
  <tr> 
   <th>方法声明</th> 
   <th>功能描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>void wait()</code></td> 
   <td>是当前线程放弃同步锁并进入等待，直到其他线程进入此同步锁，并调用<code>notify()</code>方法，或<code>notifyAll()</code>方法唤醒该线程为止</td> 
  </tr> 
  <tr> 
   <td><code>void notify()</code></td> 
   <td>唤醒此同步锁上等待的第一个调用<code>wait()</code>方法的线程</td> 
  </tr> 
  <tr> 
   <td><code>void notifyAll()</code></td> 
   <td>唤醒此同步锁上调用<code>wait()</code>方法的所有线程</td> 
  </tr> 
 </tbody> 
</table>

> 这三个方法调用的都应该是同步锁对象，如果这三个方法的调用者不是同步锁对象，Java虚拟机会抛出`IllegalMonitorStateException`异常。

接下来我们使用wait()方法和notify()方法，对例5-15进行改写来实现线程间的通信：

/** * 定义一个盘子 */
    class Plate { 
    
        // 栗子存储的空间
        private int[] cells = new int[1];
    
        // inPos表示存入的时候数组的下标，outPos表示取出的时候数组的下标
        private int inPos;
        private int outPos;
    
        // 存入或者取出数据的数量
        private int count;
    
        // 定义一个put()方法向盘子中放栗子
        public synchronized void put(int num) { 
            try { 
                // 如果数量等于数组的长度，此线程等待一下
                while (count == cells.length) { 
                    this.wait();
                }
                // 向盘子中放入栗子（想数组中放入数据）
                cells[inPos] = num;
                System.out.println("在cells[" + inPos + "]中放入了一个栗子----" + cells[inPos]);
                // 存完元素让位置+1
                inPos++;
                //当inPos为数组长度的时候，将其置为0
                if (inPos == cells.length) { 
                    inPos = 0;
                }
                // 放一个数据，count+1
                count++;
                this.notify();
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }
    
        /** * 定义一个get()方法从盘子中取出栗子 */
        public synchronized void get() { 
            try { 
                // 如果count为0，没有栗子了，就等一下
                while (count == 0) { 
                    this.wait();
                }
                int data = cells[outPos];
                System.out.println("从cells[" + outPos + "]中取出了一个栗子" + data);
                // 取完后元素位置+1
                outPos++;
                if (outPos == cells.length) { 
                    outPos = 0;
                }
                // 取出一个数据，count-1
                count--;
                this.notify();
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
        }
    }

然后我们再测试一下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 3]  
此时的数据尽管没有那么的有规律，但是我们看到放入和取出的顺序起码是对的，每次从特定位置取出的栗子都是我们最后放入的那一个。  
只要我们把盘子的大小改为1，就可以实现放一个拿一个的效果了。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 4]

[20210305170246896.png]: /images/20221023/fb66c2492a09420aad5f898735e1740c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70]: /images/20221023/bf44b0225d2442edac12fcbade46c534.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 1]: /images/20221023/5630a4ed955f4ad0aff416f67dd18950.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 2]: /images/20221023/7272730a64d54872bbe5da217e6780a6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 3]: /images/20221023/b33091f0135a4864ac001a0acdbb5cab.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3UwMTQ1NjUxMjc_size_16_color_FFFFFF_t_70 4]: /images/20221023/0ba74905965848bf8b32b7fe681c464e.png