Java-多线程的使用

小灰灰 2023-09-29 15:34 15阅读 0赞

### 线程的安全 ###

*  一、基本概念：程序、进程、线程
 *   *  1. 概述
     *  2. 使用多线程的优点
     *  3. 何时需要多线程？
 *  二、线程的创建和使用
 *   *  1. Thread类的特性
     *  2. Thread类的构造器
     *  3. Thread类的有关方法与优先级
     *   *  3.1 方法
         *  3.2 优先级
     *  4. 创建线程的四种方式
     *   *  4.1 方式一：继承于Thread类
         *   *  （1）步骤
             *  （2）注意
             *  （3）代码演示
         *  4.2 方式二：实现Runnable接口
         *   *  （1）步骤
             *  （2）代码演示
         *  4.3 方式三：实现Callable接口（JDK5.0）
         *   *  （1）优点
             *  （2）Future接口
             *  （3）代码演示
         *  4.4 方式四：使用线程池（JDK5.0）
         *   *  （1）背景
             *  （2）思路
             *  （3）优点
             *  （4）线程池相关API
             *  （5）代码演示
         *  4.5 继承方式和实现方式的联系与区别
 *  三、线程的生命周期
 *  四、解决线程的安全问题
 *   *  1. 引入
     *   *  1.1 问题
         *  1.2 原因
         *  1.3 解决
     *  2. 解决方案
     *   *  2.1 方式一：同步代码块
         *   *  2.1.1 继承于Thread类
             *  2.1.2 实现Runnable接口
         *  2.2 方式二：同步方法
         *   *  2.2.1 继承于Thread类
             *  2.2.2 实现Runnable接口
         *  2.3 方式三：Lock(锁)（JDK 5.0）
     *  3. 同步机制中的锁
     *   *  3.1 同步锁机制
         *  3.2 synchronized的锁是什么？
         *  3.3 注意
         *  3.4 同步范围
         *  3.5 释放锁的操作
         *  3.6 不会释放锁的操作
     *  4. 线程的死锁问题
     *   *   *  4.1 原因
             *  4.2 后果
             *  4.3 解决方法
         *  4.4 代码演示
 *  五、线程的通信
 *   *  1. 有关方法
     *   *  1.1 wait（）
         *  1.2 notify() / notifyAll（）
         *  1.3 wait() 与 notify() 和 notifyAll()
         *  1.4 sleep() 和 wait()的异同？
     *  2. 代码演示

--------------------

# 一、基本概念：程序、进程、线程 #

## 1. 概述 ##

> ⭕ **程序(program)**  
> 为完成特定任务、用某种语言编写的一组指令的集合。即指一段**静态的代码，静态对象**。

> ⭕ **进程(process)**  
> 是程序的一次执行过程，或是正在运行的一个程序。是一个**动态的过程**：有它自身的产生、存在和消亡的过程。——生命周期  
> 如：运行中的QQ，运行中的MP3播放器  
> 注意：程序是**静态**的，进程是**动态**的，进程作为资源分配的单位，系统在运行时会为每个进程分配**不同**的内存区域。

> ⭕**线程(thread)**  
> ● 进程可进一步细化为线程，是一个程序内部的一条执行路径。 若一个进程同一时间并行执行多个线程，就是支持多线程的。  
> ● 线程作为调度和执行的单位，每个线程拥有独立的运行栈和程序计数器(pc)，线程切换的开销小 。一个进程中的多个线程共享**相同的内存单元/内存地址空间**。它们从同一堆中分配对象，可以访问相同的变量和对象。这就使得线程间通信更简便、高效。但多个线程操作共享的系统资源可能就会带来安全的隐患。  
> ● 进程可以细化为多个线程，每个线程拥有自己独立的：栈、程序计数器，多个线程共享同一个进程中的结构：方法区、堆。

![在这里插入图片描述][1546de931a154c47a1547bcd95a3cee3.png]

> ⭕ **单核CPU和多核CPU的理解**  
> ● 单核CPU，其实是一种假的多线程，因为在一个时间单元内，也只能执行一个线程的任务。例如：虽然有多车道，但是收费站只有一个工作人员在收费，只有收了费才能通过，那么CPU就好比收费人员。如果有某个人不想交钱，那么收费人员可以把它“挂起”（晾着他，等他想通了，准备好了钱，再去收费）。但是因为CPU时间单元特别短，因此感觉不出来。  
> ● 多核CPU，才能更好的发挥多线程的效率。（现在的服务器都是多核的）一个Java应用程序java.exe，其实至少有三个线程：main()主线程，gc()垃圾回收线程，异常处理线程。当然如果发生异常，会影响主线程。

> ⭕ **并行与并发**  
> 并行：多个CPU同时执行多个任务。比如：多个人同时做不同的事。  
> 并发：一个CPU(采用时间片)同时执行多个任务。比如：秒杀、多个人做同一件事。

## 2. 使用多线程的优点 ##

> 背景：以单核CPU为例，只使用单个线程先后完成多个任务（调用多个方法），肯定比用多个线程来完成用的时间更短，为何仍需多线程呢？  
> 多线程程序的优点：
> 
> 1.  提高应用程序的响应。对图形化界面更有意义，可增强用户体验。
> 2.  提高计算机系统CPU的利用率。
> 3.  改善程序结构。将既长又复杂的进程分为多个线程，独立运行，利于理解和修改。

## 3. 何时需要多线程？ ##

> ① 程序需要同时执行两个或多个任务。  
> ② 程序需要实现一些需要等待的任务时，如用户输入、文件读写 操作、网络操作、搜索等。  
> ③ 需要一些后台运行的程序时。

# 二、线程的创建和使用 #

## 1. Thread类的特性 ##

> ⭕ Java语言的`JVM`允许程序运行多个线程，它通过`java.lang.Thread` 类来体现。

> ⭕ 每个线程都是通过某个特定`Thread`对象的`run()`方法来完成操作的，经常把`run()`方法的主体称为线程体。

> ⭕ 通过该`Thread`对象的`start()`方法来启动这个线程，而非直接调用`run()`。

## 2. Thread类的构造器 ##

<table> 
 <thead> 
  <tr> 
   <th>构造器</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>Thread()</code></td> 
   <td>创建新的<code>Thread</code>对象</td> 
  </tr> 
  <tr> 
   <td><code>Thread(String threadname)</code></td> 
   <td>创建线程并指定线程实例名</td> 
  </tr> 
  <tr> 
   <td><code>Thread(Runnable target)</code></td> 
   <td>指定创建线程的目标对象，它实现了<code>Runnable</code>接口中的<code>run</code>方法</td> 
  </tr> 
  <tr> 
   <td><code>Thread(Runnable target, String name)</code></td> 
   <td>创建新的<code>Thread</code>对象</td> 
  </tr> 
 </tbody> 
</table>

## 3. Thread类的有关方法与优先级 ##

### 3.1 方法 ###

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>void start()</code></td> 
   <td>启动线程，并执行对象的<code>run()</code>方法。</td> 
  </tr> 
  <tr> 
   <td><code>run()</code></td> 
   <td>线程在被调度时执行的操作</td> 
  </tr> 
  <tr> 
   <td><code>Strng getName()</code></td> 
   <td>返回线程的名称</td> 
  </tr> 
  <tr> 
   <td><code>void setName(String name)</code></td> 
   <td>设置该线程名称</td> 
  </tr> 
  <tr> 
   <td><code>static Thread currentThread()</code></td> 
   <td>返回当前线程。在<code>Thread</code>子类中就是this，通常用于主线程和<code>Runnable</code>实现类</td> 
  </tr> 
  <tr> 
   <td><code>static void yield()</code></td> 
   <td>线程让步，释放当前<code>cpu</code>的执行权，暂停当前正在执行的线程，把执行机会让给优先级相同或更高的线程，若队列中没有同优先级的线程，忽略此方法。</td> 
  </tr> 
  <tr> 
   <td><code>join()</code></td> 
   <td>在线程a中调用线程b的<code>join()</code>,此时线程<code>a</code>就进入阻塞状态，直到线程<code>b</code>完全执行完以后，线程<code>a</code>才结束阻塞状态。低优先级的线程也可以获得执行。</td> 
  </tr> 
  <tr> 
   <td><code>static void sleep(long millis)</code>(指定时间:毫秒)</td> 
   <td>① 令当前活动线程在指定时间段内放弃对CPU控制,使其他线程<strong>有机会</strong>被执行,时间到后重排队。② 抛出<code>InterruptedException</code>异常</td> 
  </tr> 
  <tr> 
   <td><code>stop()</code></td> 
   <td>强制线程生命期结束，不推荐使用</td> 
  </tr> 
  <tr> 
   <td><code>boolean isAlive()</code></td> 
   <td>返回<code>boolean</code>，判断线程是否还活着。</td> 
  </tr> 
  <tr> 
   <td><code>stop()</code></td> 
   <td>已过时。当执行此方法时，强制结束当前线程。</td> 
  </tr> 
 </tbody> 
</table>

### 3.2 优先级 ###

**（1）调度策略**

> ⭕ 时间片：

![在这里插入图片描述][623ed13f70474c46a088b403dcee1cf3.png]

> ⭕ 抢占式： 高优先级的线程抢占CPU

**（2）Java的调度方法**

> ⭕ 同优先级线程组成先进先出队列（先到先服务），使用时间片策略。  
> ⭕ 对高优先级，使用优先调度的抢占式策略。

**（3）线程的优先级等级**

> `MAX_PRIORITY`：10  
> `MIN _PRIORITY`：1  
> `NORM_PRIORITY`：5

**（4）涉及的方法**

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>getPriority()</code></td> 
   <td>返回线程优先值</td> 
  </tr> 
  <tr> 
   <td><code>setPriority(int newPriority)</code></td> 
   <td>改变线程的优先级</td> 
  </tr> 
 </tbody> 
</table>

**（5）说明**

> ⭕ 线程创建时继承父线程的优先级。  
> ⭕ 低优先级只是获得调度的概率低，并非一定是在高优先级线程之后才被调用。

**（6）代码演示**

class HelloThread extends Thread{
        
        @Override
        public void run() {
        
            for (int i = 0; i < 100; i++) {
        
                if(i % 2 == 0){
        
    
    //                try {
        
    //                    sleep(10);
    //                } catch (InterruptedException e) {
        
    //                    e.printStackTrace();
    //                }
    
                    System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + ":" + i);
                }
    
    //            if(i % 20 == 0){
        
    //                yield();
    //            }
    
            }
        }
        public HelloThread(String name){
        
            super(name);
        }
    }
    
    
    public class ThreadMethodTest {
        
        public static void main(String[] args) {
        
            HelloThread h1 = new HelloThread("Thread：1");
    //        h1.setName("线程一");
            //设置分线程的优先级
            h1.setPriority(Thread.MAX_PRIORITY);
            h1.start();
            //给主线程命名
            Thread.currentThread().setName("主线程");
            Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
            for (int i = 0; i < 100; i++) {
        
                if(i % 2 == 0){
        
                System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + ":" + i);
                }
    
    //            if(i == 20){
        
    //                try {
        
    //                    h1.join();
    //                } catch (InterruptedException e) {
        
    //                    e.printStackTrace();
    //                }
    //            }
    
            }
    
    //        System.out.println(h1.isAlive());
    
        }
    }

## 4. 创建线程的四种方式 ##

> ⭕ JDK1.5之前创建新执行线程有两种方法：  
> ① 继承于`Thread`类  
> ② 实现`Runnable`接口

> ⭕ JDK1.5之后创建新执行线程新增了两种方法:  
> ① 实现`Callable`接口  
> ② 使用线程池

### 4.1 方式一：继承于Thread类 ###

#### （1）步骤 ####

> ① 创建一个继承于`Thread`类的子类。  
> ② 重写`Thread`类的`run()` \--> 将此线程执行的操作声明在`run()`中。  
> ③ 创建`Thread`类的子类的对象。  
> ④ 通过此对象调用`start()`。

#### （2）注意 ####

> ⭕ 如果自己手动调用`run()`方法，那么就只是普通方法，没有启动多线程模式。  
> ⭕ `run()`方法由`JVM`调用，什么时候调用，执行的过程控制都由操作系统的CPU调度决定。  
> ⭕ 想要启动多线程，必须调用`start()`方法。  
> ⭕ 一个线程对象只能调用一次`start()`方法启动，如果重复调用了，则将抛出以下的异常`IllegalThreadStateException`。

#### （3）代码演示 ####

//例子：遍历100以内的所有的偶数
    
    //1. 创建一个继承于Thread类的子类
    class MyThread extends Thread {
        
    //2. 重写Thread类的run()
        @Override
        public void run() {
        
            for (int i = 0; i < 100; i++) {
        
                if(i % 2 == 0){
        
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                }
            }
        }
    }
    
    
    public class ThreadTest {
        
        public static void main(String[] args) {
        
            //3. 创建Thread类的子类的对象
            MyThread t1 = new MyThread();
    
            //4.通过此对象调用start():①启动当前线程 ② 调用当前线程的run()
            t1.start();
            //问题一：我们不能通过直接调用run()的方式启动线程。
    //        t1.run(); 体现的是“对象调方法”，并没有启动另一条线程
    
            //问题二：再启动一个线程，遍历100以内的偶数。不可以还让已经start()的线程去执行。会报IllegalThreadStateException
    //        t1.start();
            //我们需要重新创建一个线程的对象
            MyThread t2 = new MyThread();
            t2.start();
    
    
            //如下操作仍然是在main线程中执行的。
            for (int i = 0; i < 100; i++) {
        
                if(i % 2 == 0){
        
                    System.out.println(Thread.currentThread().getName() + ":" + i + "***********main()************");
                }
            }
        }
    }

### 4.2 方式二：实现Runnable接口 ###

#### （1）步骤 ####

> ① 创建一个实现了`Runnable`接口的类。  
> ② 实现类去实现`Runnable`中的抽象方法：`run()`。  
> ③ 创建实现类的对象。  
> ④ 将此对象作为参数传递到`Thread`类的构造器中，创建`Thread`类的对象。  
> ⑤ 通过`Thread`类的对象调用`start()`，开启线程，调用`Runnable`子类接口的run方法。

#### （2）代码演示 ####

//1. 创建一个实现了Runnable接口的类
    class MThread implements Runnable{
        
    
        //2. 实现类去实现Runnable中的抽象方法：run()
        @Override
        public void run() {
        
            for (int i = 0; i < 100; i++) {
        
                if(i % 2 == 0){
        
                    System.out.println(Thread.currentThread().getName() + ":" + i);
                }
            }
        }
    }
    
    
    public class ThreadTest1 {
        
        public static void main(String[] args) {
        
            //3. 创建实现类的对象
            MThread mThread = new MThread();
            //4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
            Thread t1 = new Thread(mThread);
            t1.setName("线程1");
            //5. 通过Thread类的对象调用start():① 启动线程 ②调用当前线程的run()-->调用了Runnable类型的target的run()
            t1.start();
    
            //再启动一个线程，遍历100以内的偶数
            Thread t2 = new Thread(mThread);
            t2.setName("线程2");
            t2.start();
        }
    }

### 4.3 方式三：实现Callable接口（JDK5.0） ###

#### （1）优点 ####

> 与使用`Runnable`相比，`Callable`功能更强大些 ：  
> ⭕ 相比`run()`方法，可以有返回值 。  
> ⭕ 方法可以抛出异常 。  
> ⭕ 支持泛型的返回值。  
> ⭕ 需要借助`FutureTask`类，比如获取返回结果。

#### （2）Future接口 ####

> ⭕ 可以对具体`Runnable`、`Callable`任务的执行结果进行取消、查询是 否完成、获取结果等。

> ⭕ `FutrueTask`是`Futrue`接口的唯一的实现类。

> ⭕ `FutureTask` 同时实现了`Runnable`, `Future`接口。它既可以作为`Runnable`被线程执行，又可以作为`Future`得到`Callable`的返回值。

#### （3）代码演示 ####

//1.创建一个实现Callable的实现类
    class NumThread implements Callable{
        
        //2.实现call方法，将此线程需要执行的操作声明在call()中
        @Override
        public Object call() throws Exception {
        
            int sum = 0;
            for (int i = 1; i <= 100; i++) {
        
                if(i % 2 == 0){
        
                    System.out.println(i);
                    sum += i;
                }
            }
            return sum;
        }
    }
    
    
    public class ThreadNew {
        
        public static void main(String[] args) {
        
            //3.创建Callable接口实现类的对象
            NumThread numThread = new NumThread();
            //4.将此Callable接口实现类的对象作为传递到FutureTask构造器中，创建FutureTask的对象
            FutureTask futureTask = new FutureTask(numThread);
            //5.将FutureTask的对象作为参数传递到Thread类的构造器中，创建Thread对象，并调用start()
            new Thread(futureTask).start();
    
            try {
        
                //6.获取Callable中call方法的返回值
                //get()返回值即为FutureTask构造器参数Callable实现类重写的call()的返回值。
                Object sum = futureTask.get();
                System.out.println("总和为：" + sum);
            } catch (InterruptedException e) {
        
                e.printStackTrace();
            } catch (ExecutionException e) {
        
                e.printStackTrace();
            }
        }
    
    }

### 4.4 方式四：使用线程池（JDK5.0） ###

#### （1）背景 ####

> 经常创建和销毁、使用量特别大的资源，比如并发情况下的线程，对性能影响很大。

#### （2）思路 ####

> 提前创建好多个线程，放入线程池中，使用时直接获取，使用完放回池中。可以避免频繁创建销毁、实现重复利用。类似生活中的公共交通工具。

#### （3）优点 ####

> ⭕ 提高响应速度（减少了创建新线程的时间）  
> ⭕ 降低资源消耗（重复利用线程池中线程，不需要每次都创建）  
> ⭕ 便于线程管理  
> `corePoolSize`：核心池的大小  
> `maximumPoolSize`：最大线程数  
> `keepAliveTime`：线程没有任务时最多保持多长时间后会终止

#### （4）线程池相关API ####

> `JDK 5.0`起提供了线程池相关`API`：`ExecutorService` 和 `Executors`

> ⭕ `ExecutorService`：真正的线程池接口。常见子类`ThreadPoolExecutor`

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>void execute(Runnable command)</code></td> 
   <td>执行任务/命令，没有返回值，一般用来执行<code>Runnable</code></td> 
  </tr> 
  <tr> 
   <td><code>&lt;T&gt;Future&lt;T&gt; submit(Callable&lt;T&gt; task)</code></td> 
   <td>执行任务，有返回值，一般用来执行 <code>Callable</code></td> 
  </tr> 
  <tr> 
   <td><code>void shutdown()</code></td> 
   <td>关闭连接池</td> 
  </tr> 
 </tbody> 
</table>

> ⭕ `Executors`：工具类、线程池的工厂类，用于创建并返回不同类型的线程池 。

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>作用</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><code>Executors.newCachedThreadPool()</code></td> 
   <td>创建一个可根据需要创建新线程的线程池</td> 
  </tr> 
  <tr> 
   <td><code>Executors.newFixedThreadPool(n)</code></td> 
   <td>创建一个可重用固定线程数的线程池</td> 
  </tr> 
  <tr> 
   <td><code>Executors.newSingleThreadExecutor()</code></td> 
   <td>创建一个只有一个线程的线程池</td> 
  </tr> 
  <tr> 
   <td><code>Executors.newScheduledThreadPool(n)</code></td> 
   <td>创建一个线程池，它可安排在给定延迟后运行命令或者定期地执行</td> 
  </tr> 
 </tbody> 
</table>

#### （5）代码演示 ####

class NumberThread implements Runnable{
        
    
        @Override
        public void run() {
        
            for(int i = 0;i <= 100;i++){
        
                if(i % 2 == 0){
        
                    System.out.println(Thread.currentThread().getName() + ": " + i);
                }
            }
        }
    }
    
    class NumberThread1 implements Runnable{
        
    
        @Override
        public void run() {
        
            for(int i = 0;i <= 100;i++){
        
                if(i % 2 != 0){
        
                    System.out.println(Thread.currentThread().getName() + ": " + i);
                }
            }
        }
    }
    
    public class ThreadPool {
        
    
        public static void main(String[] args) {
        
            //1. 提供指定线程数量的线程池
            ExecutorService service = Executors.newFixedThreadPool(10);
            ThreadPoolExecutor service1 = (ThreadPoolExecutor) service;
            //设置线程池的属性
    //        System.out.println(service.getClass());
    //        service1.setCorePoolSize(15);
    //        service1.setKeepAliveTime();
    
    
            //2.执行指定的线程的操作。需要提供实现Runnable接口或Callable接口实现类的对象
            service.execute(new NumberThread());//适合适用于Runnable
            service.execute(new NumberThread1());//适合适用于Runnable
    
    //        service.submit(Callable callable);//适合使用于Callable
            //3.关闭连接池
            service.shutdown();
        }
    
    }

### 4.5 继承方式和实现方式的联系与区别 ###

> 开发中：优先选择**实现`Runnable`接口**的方式 。  
> 原因：  
> ⭕ 实现的方式没有类的单继承性的局限性  
> ⭕ 实现的方式更适合来处理多个线程有共享数据的情况。

# 三、线程的生命周期 #

> `JDK`中用`Thread.State`类定义了线程的几种状态 。  
> 要想实现多线程，必须在主线程中创建新的线程对象。`Java`语言使用`Thread`类及其子类的对象来表示线程，在它的一个完整的生命周期中通常要经历如下的五种状态：  
> ⭕ **新建**：当一个`Thread`类或其子类的对象被声明并创建时，新生的线程对象处于新建状态。  
> ⭕ **就绪**：处于新建状态的线程被`start()`后，将进入线程队列等待`CPU`时间片，此时它已具备了运行的条件，只是没分配到`CPU`资源。  
> ⭕ **运行**：当就绪的线程被调度并获得`CPU`资源时,便进入运行状态， `run()`方法定义了线 程的操作和功能。  
> ⭕ **阻塞**：在某种特殊情况下，被人为挂起或执行输入输出操作时，让出 `CPU` 并临时中止自己的执行，进入阻塞状态。阻塞状态为临时状态，不可以作为最终状态。  
> ⭕ **死亡**：线程完成了它的全部工作或线程被提前强制性地中止或出现异常导致结束，是所有线程的最终状态。

![在这里插入图片描述][439b8b42ab13441cbdcd0d585d984401.png]

# 四、解决线程的安全问题 #

## 1. 引入 ##

### 1.1 问题 ###

> 创建三个窗口卖票，总票数为100张，卖票过程中，出现了重票、错票 -->出现了线程的安全问题。

### 1.2 原因 ###

> 当某个线程操作车票的过程中，尚未操作完成时，其他线程参与进来，也操作车票。

### 1.3 解决 ###

> 一个线程`a`在操作`ticket`的时候，其他线程不能参与进来。在`Java`中，我们通过同步机制，来解决线程的安全问题。直到线程`a`操作完`ticket`时，其他线程才可以开始操作`ticket`。这种情况即使线程`a`出现了阻塞，也不能被改变。

## 2. 解决方案 ##

### 2.1 方式一：同步代码块 ###

**（1）语法格式:**

synchronized(同步监视器){
        
      //需要被同步的代码   
    }

**（2）说明**

> ⭕ 操作共享数据的代码，即为需要被同步的代码。 -->不能包含代码多了，也不能包含代码少了。范围太小：没锁住所有有安全问题的代码。范围太大：没发挥多线程的功能。

> ⭕ 共享数据：多个线程共同操作的变量。比如：`ticket`就是共享数据。

> ⭕ 同步监视器，俗称：锁。任何一个类的对象，都可以充当锁。要求：多个线程必须要共用**同一把锁**。

> ⭕ 实现`Runnable`接口创建多线程的方式中，我们可以考虑使用`this`充当同步监视器。

#### 2.1.1 继承于Thread类 ####

class Window2 extends Thread{
        
    
        private static int ticket = 100;
        private static Object obj = new Object();
    
        @Override
        public void run() {
        
    
            while(true){
        
                //正确的
    //            synchronized (obj){
        
                synchronized (Window2.class){
        //Class clazz = Window2.class,Window2.class只会加载一次
                    //错误的方式：this代表着t1,t2,t3三个对象
    //              synchronized (this){
        
    
                    if(ticket > 0){
        
    
                        try {
        
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
    
                        System.out.println(getName() + "：卖票，票号为：" + ticket);
                        ticket--;
                    }else{
        
                        break;
                    }
                }
            }
        }
    }
    
    
    public class WindowTest2 {
        
        public static void main(String[] args) {
        
            Window2 t1 = new Window2();
            Window2 t2 = new Window2();
            Window2 t3 = new Window2();
    
    
            t1.setName("窗口1");
            t2.setName("窗口2");
            t3.setName("窗口3");
    
            t1.start();
            t2.start();
            t3.start();
        }
    }

#### 2.1.2 实现Runnable接口 ####

class Window1 implements Runnable{
        
    
        private int ticket = 100;
    //    Object obj = new Object();
    //    Dog dog = new Dog();
        @Override
        public void run() {
        
    //        Object obj = new Object();
            while(true){
        
                synchronized (this){
        //此时的this:唯一的Window1的对象   //方式二：synchronized (dog) {
        
                    if (ticket > 0) {
        
                        try {
        
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                        System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
                        ticket--;
                    } else {
        
                        break;
                    }
                }
            }
        }
    }
    
    
    public class WindowTest1 {
        
        public static void main(String[] args) {
        
            Window1 w = new Window1();
    
            Thread t1 = new Thread(w);
            Thread t2 = new Thread(w);
            Thread t3 = new Thread(w);
    
            t1.setName("窗口1");
            t2.setName("窗口2");
            t3.setName("窗口3");
    
            t1.start();
            t2.start();
            t3.start();
        }
    }
    //    class Dog{ }

### 2.2 方式二：同步方法 ###

**（1）语法格式**

public synchronized void show (String name){
        
      // …. 
     }

**（2）说明**

> ⭕ 如果操作共享数据的代码完整的声明在一个方法中，我们不妨将此方法声明同步的。
> 
> ⭕ 同步方法仍然涉及到同步监视器，只是不需要我们显式的声明。  
> ⭕  
> 非静态的同步方法，同步监视器是：this。  
> 静态的同步方法，同步监视器是：当前类本身。

#### 2.2.1 继承于Thread类 ####

class Window4 extends Thread {
        
    
        private static int ticket = 100;
    
        @Override
        public void run() {
        
    
            while (true) {
        
                show();
            }
    
        }
        private static synchronized void show(){
        //同步监视器：Window4.class
            //private synchronized void show(){ //同步监视器：t1,t2,t3。此种解决方式是错误的
            if (ticket > 0) {
        
    
                try {
        
                    Thread.sleep(100);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
    
                System.out.println(Thread.currentThread().getName() + "：卖票，票号为：" + ticket);
                ticket--;
            }
        }
    }
    
    
    public class WindowTest4 {
        
        public static void main(String[] args) {
        
            Window4 t1 = new Window4();
            Window4 t2 = new Window4();
            Window4 t3 = new Window4();
    
    
            t1.setName("窗口1");
            t2.setName("窗口2");
            t3.setName("窗口3");
    
            t1.start();
            t2.start();
            t3.start();
    
        }
    }

#### 2.2.2 实现Runnable接口 ####

class Window3 implements Runnable {
        
    
        private int ticket = 100;
    
        @Override
        public void run() {
        
            while (true) {
        
    
                show();
            }
        }
    
        private synchronized void show(){
        //同步监视器：this
            //synchronized (this){
        
    
                if (ticket > 0) {
        
    
                    try {
        
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
    
                    System.out.println(Thread.currentThread().getName() + ":卖票，票号为：" + ticket);
    
                    ticket--;
                }
            //}
        }
    }
    
    public class WindowTest3 {
        
        public static void main(String[] args) {
        
            Window3 w = new Window3();
    
            Thread t1 = new Thread(w);
            Thread t2 = new Thread(w);
            Thread t3 = new Thread(w);
    
            t1.setName("窗口1");
            t2.setName("窗口2");
            t3.setName("窗口3");
    
            t1.start();
            t2.start();
            t3.start();
        }
    }

### 2.3 方式三：Lock(锁)（JDK 5.0） ###

**（1）代码演示**

class Window implements Runnable{
        
    
        private int ticket = 100;
        //1.实例化ReentrantLock
        private ReentrantLock lock = new ReentrantLock();
    
        @Override
        public void run() {
        
            while(true){
        
                try{
        
    
                    //2.调用锁定方法lock()
                    lock.lock();
    
                    if(ticket > 0){
        
    
                        try {
        
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
    
                        System.out.println(Thread.currentThread().getName() + "：售票，票号为：" + ticket);
                        ticket--;
                    }else{
        
                        break;
                    }
                }finally {
        
                    //3.调用解锁方法：unlock()
                    //如果同步代码有异常，要将unlock()写入finally语句块
                    lock.unlock();
                }
    
            }
        }
    }
    
    public class LockTest {
        
        public static void main(String[] args) {
        
            Window w = new Window();
    
            Thread t1 = new Thread(w);
            Thread t2 = new Thread(w);
            Thread t3 = new Thread(w);
    
            t1.setName("窗口1");
            t2.setName("窗口2");
            t3.setName("窗口3");
    
            t1.start();
            t2.start();
            t3.start();
        }
    }

**（2）说明**

> ⭕ 从`JDK 5.0`开始，，`Java`提供了更强大的线程同步机制——通过显式定义同步锁对象来实现同步。同步锁使用`Lock`对象充当。

> ⭕ `java.util.concurrent.locks.Lock`接口是控制多个线程对共享资源进行访问的工具。锁提供了对共享资源的独占访问，每次只能有一个线程对`Lock`对象加锁，线程开始访问共享资源之前应先获得`Lock`对象。

> ⭕ `ReentrantLock` 类实现了 `Lock` ，它拥有与 `synchronized`相同的并发性和内存语义，在实现线程安全的控制中，比较常用的是`ReentrantLock`，可以显式加锁、释放锁。

**（3）synchronized 与 Lock 的对比**

> ⭕ `Lock`是显式锁（手动开启和关闭锁，别忘记关闭锁），`synchronized`是隐式锁，出了作用域自动释放。

> ⭕ `Lock`只有代码块锁，`synchronized`有代码块锁和方法锁。

> ⭕ 使用`Lock`锁，`JVM`将花费较少的时间来调度线程，性能更好。并且具有更好的扩展性（提供更多的子类）。

**（4）优先使用顺序**

> ① `Lock`  
> ② 同步代码块（已经进入了方法体，分配了相应资源）  
> ③ 同步方法（在方法体之外）

## 3. 同步机制中的锁 ##

### 3.1 同步锁机制 ###

> 在`《Thinking in Java》`中，是这么说的：对于并发工作，你需要某种方式来防止两个任务访问相同的资源（其实就是共享资源竞争）。  
> 防止这种冲突的方法就是当资源被一个任务使用时，在其上加锁。第一个访问某项资源的任务必须锁定这项资源，使其他任务在其被解锁之前，就无法访问它了，而在其被解锁之时，另一个任务就可以锁定并使用它了。

### 3.2 synchronized的锁是什么？ ###

> 任意对象都可以作为同步锁。所有对象都自动含有单一的锁（监视器）。  
> ⭕ 同步方法的锁：静态方法（类名`.class`）、非静态方法（`this`）。  
> ⭕ 同步代码块的锁：自己指定，很多时候也是指定为`this`或`类名.class`。

### 3.3 注意 ###

> ⭕ 必须确保使用同一个资源的多个线程共用一把锁，这个非常重要，否则就无法保证共享资源的安全。

> ⭕ 一个线程类中的所有静态方法共用同一把锁（`类名.class`），所有非静态方法共用同一把锁（`this`），同步代码块（指定需谨慎）。

### 3.4 同步范围 ###

⭕ 如何确认代码是否存在线程安全？

> ● 明确哪些代码是多线程运行的代码。  
> ● 明确多个线程是否有共享数据。  
> ● 明确多线程运行代码中是否有多条语句操作共享数据。

⭕ 如何解决呢？

> 对多条操作共享数据的语句，只能让一个线程都执行完，在执行过程中，其它线程不可以参与执行。即所有操作共享数据的这些语句都要放在同步范围中。

### 3.5 释放锁的操作 ###

> ⭕ 当前线程的同步方法、同步代码块执行结束。

> ⭕ 当前线程在同步代码块、同步方法中遇到`break`、`return`终止了该代码块、该方法的继续执行。

> ⭕ 当前线程在同步代码块、同步方法中出现了未处理的`Error`或`Exception`，导致异常结束。

> ⭕ 当前线程在同步代码块、同步方法中执行了线程对象的`wait()`方法，当前线程暂停，并释放锁。

### 3.6 不会释放锁的操作 ###

> ⭕ 线程执行同步代码块或同步方法时，程序调用`Thread.sleep()`、`Thread.yield()`方法暂停当前线程的执行。

> ⭕ 线程执行同步代码块时，其他线程调用了该线程的`suspend()`方法将该线程挂起，该线程不会释放锁（同步监视器）。

> ⭕ 应尽量避免使用`suspend()`和`resume()`来控制线程。

## 4. 线程的死锁问题 ##

#### 4.1 原因 ####

> 不同的线程分别占用对方需要的同步资源不放弃，都在等待对方放弃自己需要的同步资源，就形成了线程的死锁。

#### 4.2 后果 ####

> 出现死锁后，不会出现异常，不会出现提示，只是所有的线程都处于阻塞状态，无法继续。

#### 4.3 解决方法 ####

> ⭕ 专门的算法、原则。  
> ⭕ 尽量减少同步资源的定义。  
> ⭕ 尽量避免嵌套同步。

### 4.4 代码演示 ###

**演示一：**

class A {
        
    	public synchronized void foo(B b) {
         //同步监视器：A类的对象：a
    		System.out.println("当前线程名: " + Thread.currentThread().getName()
    				+ " 进入了A实例的foo方法"); // ①
    //		try {
        
    //			Thread.sleep(200);
    //		} catch (InterruptedException ex) {
        
    //			ex.printStackTrace();
    //		}
    		System.out.println("当前线程名: " + Thread.currentThread().getName()
    				+ " 企图调用B实例的last方法"); // ③
    		b.last();
    	}
    
    	public synchronized void last() {
        //同步监视器：A类的对象：a
    		System.out.println("进入了A类的last方法内部");
    	}
    }
    
    class B {
        
    	public synchronized void bar(A a) {
        //同步监视器：b
    		System.out.println("当前线程名: " + Thread.currentThread().getName()
    				+ " 进入了B实例的bar方法"); // ②
    //		try {
        
    //			Thread.sleep(200);
    //		} catch (InterruptedException ex) {
        
    //			ex.printStackTrace();
    //		}
    		System.out.println("当前线程名: " + Thread.currentThread().getName()
    				+ " 企图调用A实例的last方法"); // ④
    		a.last();
    	}
    
    	public synchronized void last() {
        //同步监视器：b
    		System.out.println("进入了B类的last方法内部");
    	}
    }
    
    public class DeadLock implements Runnable {
        
    	A a = new A();
    	B b = new B();
    
    	public void init() {
        
    		Thread.currentThread().setName("主线程");
    		// 调用a对象的foo方法
    		a.foo(b);
    		System.out.println("进入了主线程之后");
    	}
    
    	public void run() {
        
    		Thread.currentThread().setName("副线程");
    		// 调用b对象的bar方法
    		b.bar(a);
    		System.out.println("进入了副线程之后");
    	}
    
    	public static void main(String[] args) {
        
    		DeadLock dl = new DeadLock();
    		new Thread(dl).start();
    		dl.init();
    	}
    }

**演示二：**

public class ThreadTest {
        
    
        public static void main(String[] args) {
        
    
            StringBuffer s1 = new StringBuffer();
            StringBuffer s2 = new StringBuffer();
    
    
            new Thread(){
        
                @Override
                public void run() {
        
    
                    synchronized (s1){
        
    
                        s1.append("a");
                        s2.append("1");
    
                        try {
        
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
    
                        synchronized (s2){
        
                            s1.append("b");
                            s2.append("2");
    
                            System.out.println(s1);
                            System.out.println(s2);
                        }
                    }
    
                }
            }.start();
            new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    synchronized (s2){
        
    
                        s1.append("c");
                        s2.append("3");
    
                        try {
        
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                        synchronized (s1){
        
                            s1.append("d");
                            s2.append("4");
    
                            System.out.println(s1);
                            System.out.println(s2);
                        }
                    }
                }
            }).start();
        }
    }

# 五、线程的通信 #

## 1. 有关方法 ##

### 1.1 wait（） ###

> ⭕ 在当前线程中调用方法： `对象名.wait()` 。

> ⭕ 令当前线程挂起并放弃`CPU`、同步资源并等待，使别的线程可访问并修改共享资源，而当前线程排队等候其它线程调用`notify()`或`notifyAll()`方法唤醒，唤醒后等待重新获得对监视器的所有权后才能继续执行。

> ⭕ 调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁），调用此方法后，当前线程将**释放对象监控权**，然后进入等待，在当前线程**被notify后，重新获得监控权**，然后从断点处继续代码的执行。

### 1.2 notify() / notifyAll（） ###

> ⭕ 在当前线程中调用方法： `对象名.notify()`

> ⭕ 功能：唤醒正在排队等待同步资源的线程中优先级最高者结束等待 / 唤醒正在排队等待资源的所有线程结束等待。

> ⭕ 调用方法的必要条件：当前线程必须具有对该对象的监控权（加锁）。

### 1.3 wait() 与 notify() 和 notifyAll() ###

> ⭕ 这三个方法只有在`synchronized`方法或`synchronized`代码块中才能使用，否则会报`java.lang.IllegalMonitorStateException`异常。

> ⭕ `wait()`，`notify()`，`notifyAll()`三个方法是定义在`java.lang.Object`类中。因为这三个方法必须有锁对象调用，而任意对象都可以作为`synchronized`的同步锁，因此这三个方法只能是在`Object`类中声明的。

> ⭕`wait()`，`notify()`，`notifyAll()`三个方法的调用者必须是同步代码块或同步方法中的同步监视器。否则，会出现`IllegalMonitorStateException`异常

### 1.4 sleep() 和 wait()的异同？ ###

> ⭕ 相同点：一旦执行方法，都可以使得当前的线程进入**阻塞状态**。

> ⭕ 不同点：  
> ● 两个方法声明的位置不同：`Thread`类中声明`sleep()`, `Object`类中声明`wait()` 。  
> ● 调用的要求不同：`sleep()`可以在任何需要的场景下调用。`wait()`必须使用在同步代码块或同步方法中。  
> ● 关于是否释放同步监视器：如果两个方法都使用在同步代码块或同步方法中，`sleep()`不会释放锁，`wait()`会释放锁。

## 2. 代码演示 ##

class Number implements Runnable{
        
    
        private int number = 1;
        private Object obj = new Object();
        
        @Override
        public void run() {
        
            while(true){
        
                synchronized (obj) {
        
                    obj.notify();
                    if(number <= 100){
        
                    
                        try {
        
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
                        
                        System.out.println(Thread.currentThread().getName() + ":" + number);
                        number++;
    
                        try {
        
                            //使得调用如下wait()方法的线程进入阻塞状态
                            obj.wait();
                        } catch (InterruptedException e) {
        
                            e.printStackTrace();
                        }
    
                    }else{
        
                        break;
                    }
                }
            }
        }
    }
    public class CommunicationTest {
        
        public static void main(String[] args) {
        
            Number number = new Number();
            Thread t1 = new Thread(number);
            Thread t2 = new Thread(number);
    
            t1.setName("线程1");
            t2.setName("线程2");
    
            t1.start();
            t2.start();
        }
    }

[1546de931a154c47a1547bcd95a3cee3.png]: https://img-blog.csdnimg.cn/1546de931a154c47a1547bcd95a3cee3.png
[623ed13f70474c46a088b403dcee1cf3.png]: https://img-blog.csdnimg.cn/623ed13f70474c46a088b403dcee1cf3.png
[439b8b42ab13441cbdcd0d585d984401.png]: https://img-blog.csdnimg.cn/439b8b42ab13441cbdcd0d585d984401.png