Java16多线程2：线程的通信、JDK5新增创建线程的方式

我不是女神ヾ 2024-03-24 12:56 50阅读 0赞

#### 多线程2 目录 ####

*  7.线程的通信
 *   *  7.1 线程间通信
     *  7.2 等待唤醒机制
     *  7.3 举例-调用wait和notify
     *  7.4 wait()和 sleep()的区别？
     *  7.5 生产者&消费者
 *  8.JDK5 新增的两种创建线程-JUC
 *   *  8.1 实现Callable接口，创建线程（了解）
     *  8.2 使用线程池 pool

## 7.线程的通信 ##

### 7.1 线程间通信 ###

*为什么要处理线程间通信？*  
当我们`需要多个线程`共同完成一个任务，并且我们希望它们`有规律的执行`，那么多线程之间需要通信机制，可以协调它们的工作，以此实现多线程共同操作一份数据。  
比如：线程A是用来生产包子，线程B用来吃包子。那么包子就是同一资源，线程A和B处理的动作就是：A是生产者，B是消费者。此时线程B必须等到线程A完成后才能执行，那么线程A和B就需要线程通信，即 `等待唤醒机制`。

### 7.2 等待唤醒机制 ###

1）它是多个线程间的一种协作机制。线程间除了有`竞争`（race，比如：争夺锁），还有协作机制。  
当线程满足某个条件时，就进入等待状态（`wait / wait(time`)），等待其他线程执行完他们的 指定代码后再将其唤醒（`notify()`）；或进入指定 wait的时间，等时间到了自动唤醒；在有多个线程 进行等待时，如果需要，可以使用 `notifyAll()`来唤醒所有的等待线程。wait / notify 就是线程间的一种协作机制

2）三个方法的使用：

> 1.  `wait()`：线程一旦执行此方法，就进入等待状态。同时，释放同步监视器的调用
> 2.  `notify()`：线程一旦执行此方法，就会唤醒 被wait()的线程中 优先级最高的线程的那一个线程（如果优先级相同，随机选择一个）。被唤醒的线程从当初 被wait()的位置继续执行。
> 3.  `notifyAll()`：线程一旦执行此方法，就会唤醒 被wait()的所有线程。

3）注意点：

> 1.  这三各方法的使用，必须是在`同步代码块 或同步方法中`；（Lock需要配合Condition实现线程间的通信）
> 2.  这三个方法的调用者，必须是同步监视器。否则报illegalmonitorstateexception
> 
>     synchronized (obj) {
>     ...
>     	obj.notify();
>     ...
>     		obj.wait();
>     }
> 
> 1.  这三个方法声明在Object类中。

### 7.3 举例-调用wait和notify ###

使用两个线程交替打印数字：1~100

package com.mMultithreadOther;
    
    /**
     * 线程通信
     * 使用两个线程交替打印数字：1~100
     */
    class PrintNumber implements Runnable {
       
        
        private int number = 1;
    	Object obj = new Object();
        @Override
        public void run() {
       
        
            while (true) {
       
        
            	/*illegalmonitorstateexception 非法监视器状态异常
                synchronized (obj) {//obj和`this`.notify()中的this不是同一个类*/
                synchronized (this) {
       
        
                    this.notify();
                    if (number <= 100) {
       
        
                        try {
       
        
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
       
        
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + ":" + number);
                        number++;
                        try {
       
        
                            //线程一旦执行此方法，就进入等待状态。同时，释放同步监视器的调用
                            this.wait();
                        } catch (InterruptedException e) {
       
        
                            e.printStackTrace();
                        }
                    } else {
       
        
                        break;
                    }
                }
            }
        }
    }
    
    public class Test5PrintNumber {
       
        
        public static void main(String[] args) {
       
        
            PrintNumber p = new PrintNumber();
            Thread t1 = new Thread(p, "线程1");
            Thread t2 = new Thread(p, "线程2");
    
            t1.start();
            t2.start();
        }
    }

### 7.4 wait()和 sleep()的区别？ ###

1）相同点：

*  一旦执行，当前线程都会进入阻塞；

2）不同点：

<table> 
 <thead> 
  <tr> 
   <th>不同</th> 
   <th>wait()</th> 
   <th>sleep()</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>声明不同</td> 
   <td>声明在Object类中</td> 
   <td>声明在Thread类中，静态的</td> 
  </tr> 
  <tr> 
   <td>使用场景不同</td> 
   <td>只能用在同步代码块 或同步方法 中</td> 
   <td>可以在任何需要的场景中使用</td> 
  </tr> 
  <tr> 
   <td>同步代码块 或同步方法</td> 
   <td>一旦执行，会释放同步监视器</td> 
   <td>即便执行，也不会释放同步监视器</td> 
  </tr> 
  <tr> 
   <td>结束阻塞的方式</td> 
   <td>到达指定时间，自动结束 或被notify()唤醒，结束阻塞</td> 
   <td>到达指定时间自动结束阻塞</td> 
  </tr> 
 </tbody> 
</table>

### 7.5 生产者&消费者 ###

1）生产者（Producer）将产品交给店员（Clerk），而消费者（Consumer）从店员处取走产品，店员一次只能持有固定数量的产品（比如：20）。如果生产者试图生产更多的产品，店员会让生产者暂停一下，等到店中有空位了再通知生产者继续生产；如果没有产品了店员会告诉消费者等一下，等到店里有产品了再通知消费者取走产品。

2）分析：

*  1.  是否是多线程问题？ 是 生产者、消费者
 *  1.  是否有共享数据？ 是 共享产品
 *  1.  是否有线程安全问题？ 是 有共享数据
 *  1.  是否需要处理线程安全问题？ 是 如何处理？ 使用同步机制
 *  1.  是否存在线程间的通信ÿ