java多线程面试宝典

系统管理员 2022-05-14 07:18 216阅读 0赞

### 文章目录 ###

*  需要整理
 *  多线程面试
 *   *   *  1、什么是线程?什么是进程?
         *  2、多线程有什么用？
         *   *  2.1 什么是线程安全的?
             *  2.2 在 java 中守护线程和本地线程区别
             *  2.3 上下文切换
             *  2.4 java中用到的线程调度算法是什么
         *  3、java中要想实现多线程，主要有两种手段
         *   *  3.1 Runnable接口和Callable接口的区别
         *  4、start()方法和run()方法的区别
         *  5. 现在有线程 T1、T2 和 T3。你如何确保 T2 线程在 T1 之后执行，并且 T3 线程在 T2 之后执行？
         *  6. Java 中新的 Lock 接口相对于同步代码块（synchronized block）有什么优势？如果让你实现一个高性能缓存，支持并发读取和单一写入，你如何保证数据完整性。
         *  7. Java 中 wait 和 sleep 方法有什么区别？
         *  8 Java 中 CyclicBarrier 和 CountDownLatch 有什么不同
         *  9.线程并发库
         *  10.线程池
         *  11.java.util.concurrent.atomic的原子变量的类
         *   *  待完善 参考原文\[ ImportNew.com - 一杯哈希不加盐\](http://www.importnew.com/29562.html)
 *  多线程安全问题
 *   *  目录
     *   *  1.synchronized
         *   *  1.1 字节码
             *  1.2 synchronized同步代码块
             *  1.3 synchronized同步方法
         *  2. Lock和synchronized
         *  4.死锁
         *  5. java内存模型jmm
         *  6.volatile关键字
         *  7. 乐观锁与悲观锁
         *  8.多线程处理Timer
         *  CountDownLatch

# 需要整理 #

7、为什么使用 Executor 框架？  
8、在 Java 中 Executor 和 Executors 的区别？  
9、如何在 Windows 和 Linux 上查找哪个线程使用的 CPU 时间最长？  
10、什么是原子操作？在 Java Concurrency API 中有哪些原子类(atomic classes)？  
11、Java Concurrency API 中的 Lock 接口(Lock interface)是什么？对比同步它有什么优势？  
12、什么是 Executors 框架？  
13、什么是阻塞队列？阻塞队列的实现原理是什么？如何使用阻塞队列来实现生产者-消费者模型？  
14、什么是 Callable 和 Future?  
15、什么是 FutureTask?使用 ExecutorService 启动任务。  
16、什么是并发容器的实现？  
17、多线程同步和互斥有几种实现方法，都是什么？  
18、什么是竞争条件？你怎样发现和解决竞争？  
19、你将如何使用 thread dump？你将如何分析 Thread dump？165  
20、为什么我们调用 start()方法时会执行 run()方法，为什么我们不能直接调用 run()方法？

# 多线程面试 #

### 1、什么是线程?什么是进程? ###

进程：每个进程都有独立的代码和数据空间（进程上下文），进程间的切换会有较大的开销，一个进程包含1–n个线程。（进程是资源分配的基本单位）

*  进程间通信主要包括管道,  
    系统IPC（包括消息队列,信号,共享存储)  
    套接字(SOCKET).  
    管道( pipe )：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系的进程间使用。进程的亲缘关系通常是指父子进程关系。  
    FIFO（命名管道）

线程：同一类线程共享代码和数据空间，每个线程有独立的运行栈和程序计数器(PC)，线程切换开销小。（线程是cpu调度的最小单位）

线程可以创建另外一个线程  
进程有独立的虚拟地址空间  
同一进程内的线程共享内存等系统资源

*  线程间同步的方式,进程同步方式

1.  互斥量，采用互斥对象机制，只有拥有互斥对象的线程才有访问公共资源的权限。因为互斥对象只有一个，所以可以保证公共资源不会被多个线程同时访问
2.  信号量(临界区)，它允许同一时刻多个线程访问同一资源，但是需要控制同一时刻访问此资源的最大线程数量。当需要一个计数器来限制可以使用某共享资源的线程数目时，可以使用“信号量”对象
3.  事件（信号），通过通知操作的方式来保持多线程同步，还可以方便的实现多线程优先级的比较操作。即事件机制允许一个线程在处理完一个任务后，主动唤醒另外一个线程执行任务

![在这里插入图片描述][format_png]

### 2、多线程有什么用？ ###

（1）发挥多核CPU的优势 资源利用率提升，程序处理效率提高  
（2）防止阻塞,单核CPU我们还是要应用多线程，就是为了防止阻塞  
（3）便于建模,分别建立程序模型，并通过多线程分别运行这几个任务

#### 2.1 什么是线程安全的? ####

如果你的代码所在的进程中有多个线程在同时运行，而这些线程可能会同时运行这段代码。如果每次运行结果和单线程运行的结果是一样的，而且其他的变量的值也和预期的是一样的，就是线程安全的。

#### 2.2 在 java 中守护线程和本地线程区别 ####

Java线程分为两类分别为**daemon线程（守护线程）和User线程（用户线程）**，在JVM启动时候会调用main函数，main函数所在的线程是一个用户线程，这个是我们可以看到的线程，其实JVM内部同时还启动了好多守护线程，比如垃圾回收线程。  
那么守护线程和用户线程有什么区别那？  
区别之一是当最后一个用户线程结束时候，JVM会正常退出，守护线程是否结束并不影响JVM的退出。

#### 2.3 上下文切换 ####

巧妙地利用了时间片轮转的方式, CPU给每个任务都服务一定的时间，然后把当前任务的状态保存下来，在加载下一任务的状态后，继续服务下一任务。任务的状态保存及再加载, 这段过程就叫做上下文切换。

#### 2.4 java中用到的线程调度算法是什么 ####

抢占式。一个线程用完CPU之后，操作系统会根据线程优先级、线程饥饿情况等数据算出一个总的优先级并分配下一个时间片给某个线程执行。

操作系统中可能会出现某条线程常常获取到CPU控制权的情况，为了让某些优先级比较低的线程也能获取到CPU控制权，可以使用Thread.sleep(0)手动触发一次操作系统分配时间片的操作，这也是平衡CPU控制权的一种操作。

### 3、java中要想实现多线程，主要有两种手段 ###

*  一种是继续Thread类  
    class Thread1 extends Thread  
    覆写run()  
    调用: Thread1 mTh2=new Thread1(“B”);  
    mTh2.setName(“名字”);  
    mTh1.start();
 *  另外一种是实现Runable接口 实现接口的方式比继承类的方式更灵活，也能减少程序之间的耦合度，面向接口编程也是设计模式6大原则的核心。
 *  其实准确来讲，应该有三种，还有一种是实现Callable接口，并与Future、线程池结合使用

#### 3.1 Runnable接口和Callable接口的区别 ####

Runnable接口中的run()方法的返回值是void，它做的事情只是纯粹地去执行run()方法中的代码而已；  
Callable接口中的call()方法是有返回值的，是一个泛型，和Future、FutureTask配合可以用来获取异步执行的结果。

这其实是很有用的一个特性，因为多线程相比单线程更难、更复杂的一个重要原因就是因为多线程充满着未知性，某条线程是否执行了？某条线程执行了多久？某条线程执行的时候我们期望的数据是否已经赋值完毕？无法得知，我们能做的只是等待这条多线程的任务执行完毕而已。而Callable+Future/FutureTask却可以获取多线程运行的结果，可以在等待时间太长没获取到需要的数据的情况下取消该线程的任务，真的是非常有用。

//实现了callable
    ThreadDemo td = new ThreadDemo();
     //1.执行 Callable 方式，需要 FutureTask 实现类的支持，用于接收运算结果。
    FutureTask<Integer> result = new FutureTask<>(td);
    new Thread(result).start();
     //2.接收线程运算后的结果
    try { 
        Integer sum = result.get();  //FutureTask 可用于 闭锁 类似于CountDownLatch的作用，在所有的线程没有执行完成之后这里是不会执行的
        System.out.println(sum);
        System.out.println("------------------------------------");
    } catch (InterruptedException | ExecutionException e) { 
        e.printStackTrace();
    }

### 4、start()方法和run()方法的区别 ###

start ()方法被用来启动新创建的线程，而且 start ()内部调用了 run ()方法，这和直接调用 run ()方法的效果不一样。当你调用 run ()方法的时候，只会是在原来的线程中调用，没有新的线程启动，**start ()方法才会启动新线程**。也就是用start方法来启动线程,才是真正实现了多线程。而run方法只是一个普通方法。

### 5. 现在有线程 T1、T2 和 T3。你如何确保 T2 线程在 T1 之后执行，并且 T3 线程在 T2 之后执行？ ###

可以用 Thread 类的 join 方法实现这一效果。

*  t.join()方法阻塞调用此方法的线程(calling thread)，直到线程t完成，此线程再继续
 *  join方法必须在线程start方法调用之后调用才有意义。这个也很容易理解：如果一个线程都没有start，那它也就无法同步了。
 *  join方法的原理就是调用相应线程的wait方法进行等待操作的，例如A线程中调用了B线程的join方法，则相当于在A线程中调用了B线程的wait方法，当B线程执行完（或者到达等待时间），B线程会自动调用自身的notifyAll方法唤醒A线程，从而达到同步的目的。

public class JoinThreadDemo02 { 
    	public static void main(String[] args) { 
    		Thread t1 = new Thread(new Runnable() { 
    			public void run() { 
    				for (int i = 0; i < 20; i++) { 
    					System.out.println("t1,i:" + i);
    				}
    			}
    		});
    		Thread t2 = new Thread(new Runnable() { 
    			public void run() { 
    				try { 
    					t1.join();
    				} catch (Exception e) { 
    					// TODO: handle exception
    				}
    				for (int i = 0; i < 20; i++) { 
    					System.out.println("t2,i:" + i);
    				}
    			}
    		});
    		Thread t3 = new Thread(new Runnable() { 
    			public void run() { 
    				try { 
    					t2.join();
    				} catch (Exception e) { 
    					// TODO: handle exception
    				}
    				for (int i = 0; i < 20; i++) { 
    					System.out.println("t3,i:" + i);
    				}
    			}
    		});
    		t1.start();
    		t2.start();
    		t3.start();
    	}
    }

### 6. Java 中新的 Lock 接口相对于同步代码块（synchronized block）有什么优势？如果让你实现一个高性能缓存，支持并发读取和单一写入，你如何保证数据完整性。 ###

多线程和并发编程中使用 lock 接口的最大优势是它为读和写提供两个单独的锁，可以让你构建高性能数据结构，比如 ConcurrentHashMap 和条件阻塞。  
1）Lock不是Java语言内置的，synchronized是Java语言的关键字，因此是内置特性。Lock是一个类，通过这个类可以实现同步访问；

2）Lock和synchronized有一点非常大的不同，采用synchronized不需要用户去手动释放锁，当synchronized方法或者synchronized代码块执行完之后，系统会自动让线程释放对锁的占用；而Lock则必须要用户去手动释放锁，如果没有主动释放锁，就有可能导致出现死锁现象。

1.用法不一样。synchronized既可以加在方法上，也可以加载特定的代码块上，括号中表示需要锁的对象。而Lock需要显示地指定起始位置和终止位置。synchronzied是托管给jvm执行的，Lock锁定是通过代码实现的。 2.在性能上来说，如果竞争资源不激烈，两者的性能是差不多的，而当竞争资源非常激烈时（即有大量线程同时竞争），此时Lock的性能要远远优于synchronized。所以说，在具体使用时要根据适当情况选择。 3.锁的机制不一样。synchronized获得锁和释放的方式都是在块结构中，而且是自动释放锁。而Lock则需要开发人员手动去释放，并且必须在finally块中释放，否则会引起死锁问题的发生。 4.Lock是一个接口，而synchronized是Java中的关键字,synchronized是内置的语言实现； 5.synchronized在发生异常时，会自动释放线程占有的锁，因此不会导致死锁现象发生；而Lock在发生异常时，如果没有主动通过unLock()去释放锁，则很可能造成死锁现象，因此使用Lock时需要在finally块中释放锁； 6.Lock可以让等待锁的线程响应中断，而synchronized却不行，使用synchronized时，等待的线程会一直等待下去，不能够响应中断；通过Lock可以知道有没有成功获取锁，而synchronized却无法办到。Lock可以提高多个线程进行读操作的效率。

[详情请点击][Link 1]  
[详情请点击][Link 2]

### 7. Java 中 wait 和 sleep 方法有什么区别？ ###

**sleep()方法（休眠）是线程类（Thread）的静态方法**，调用此方法会让当前线程暂停执行指定的时间，  
将执行机会（CPU）让给其他线程，但是对象的锁依然保持，因此休眠时间结束后会自动恢复（线程回到就绪状态，请参考第66题中的线程状态转换图）。  
**wait()是Object类的方法**，调用对象的wait()方法导致当前线程放弃对象的锁（线程暂停执行），进入对象的等待池（wait pool），只有调用对象的notify()方法或notifyAll()方法时才能唤醒等待池中的线程进入等锁池（lockpool），如果线程重新获得对象的锁就可以进入就绪状态。

### 8 Java 中 CyclicBarrier 和 CountDownLatch 有什么不同 ###

它们都是JUC下的类，CyclicBarrier 和 CountDownLatch 都可以用来让一组线程等待其它线程。区别在于CountdownLatch计数无法被重置。如果需要重置计数，请考虑使用 CyclicBarrier。

### 9.线程并发库 ###

JDK5增加了并发库**Douglea**, `java.util.current`包中提供了对线程的优化和管理

### 10.线程池 ###

[链接][Link 3]

### 11.java.util.concurrent.atomic的原子变量的类 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NzYyNjc3_size_16_color_FFFFFF_t_70]  
这个包里面提供了一组原子类。其基本的特性就是在多线程环境下，当有多个线程同时执行这些类的实例包含的方法时，具有排他性，即当某个线程进入方法，执行其中的指令时，不会被其他线程打断，而别的线程就像自旋锁一样，一直等到该方法执行完成，才由JVM从等待队列中选择一个另一个线程进入，这只是一种逻辑上的理解。实际上是借助硬件的相关指令来实现的，不会阻塞线程(或者说只是在硬件级别上阻塞了)

#### 待完善 参考原文[ ImportNew.com - 一杯哈希不加盐][ImportNew.com -] ####

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

# 多线程安全问题 #

*  当多个线程共享**同一个全局变量或静态变量**时,做**写操作**的时候,可能受到其他线程的干扰,导致数据有问题
 *  必须在线程使用共享资源时给资源“上锁”，以阻挡其他线程的訪问。

问:如何解决多线程之间线程安全问题?  
答:使用多线程之间同步synchronized或使用锁(lock)。  
如何实现同步  
wait/notify 和synchronized或使用锁(lock)

## 目录 ##

(同步保证原子性)synchronized用法|  
lock|  
死锁|  
内存模型  
需要看的文章[啊啊啊啊啊啊啊啊][Link 4]  
synchronized能保证同一时刻最多只有一个线程执行该代码,以保证完全并发的效果 (通过锁来控制只有一个线程)  
**对象锁**  
\-方法锁(默认锁对象是this当前实例  
\-同步代码块锁(自己指定锁对象  
**类锁**  
\-synchronized修饰的静态方法或指定锁为Class对象

高并发时，同步调用应该去考量锁的性能损耗。能用无锁数据结构，就不要用锁；能  
锁区块，就不要锁整个方法体；**能用对象锁，就不要用类锁。**  
说明：尽可能使加锁的代码块工作量尽可能的小，避免在锁代码块中调用 RPC 方法。

### 1.synchronized ###

#### 1.1 字节码 ####

monitorenter  
monitorexit

#### 1.2 synchronized同步代码块 ####

synchronized(处理全局、静态变量时加锁 )  
使用synchronized时出现异常虚拟机自动帮你释放锁  
\[互斥的实现\]

import java.util.concurrent.*;
    import java.util.*;
    
    public class ThreadTest { 
    	public void g() { 
    	 //只能有一个线程访问,必须拿到锁才能访问||多个线程想同步,必须用[同一把锁]
    		synchronized (this) { //声明方式||此处上锁this
    			for (int i = 0; i < 5; i++) { 
    				System.out.println(Thread.currentThread().getName() + i);
    			}
    		}//执行完毕,释放锁,抛出异常也会释放锁
    	}
    	
    	public static void main(String[] args) { 
    		final ThreadTest t = new ThreadTest();
    		Thread t1 = new Thread(new Runnable() { 
    			public void run() { 
    				t.g();
    			}
    		}, "A");
    		Thread t2 = new Thread(new Runnable() { 
    			public void run() { 
    				t.g();
    			}
    		}, "B");
    		t1.start();
    		t2.start();
    	}
    }
    /* * Output: A0 A1 A2 A3 A4 B0 B1 B2 B3 B4 */

当一个线程在访问object对象的一个synchronized(this)同步代码块时，其他线程仍然能够访问此对象的非同步代码块。

#### 1.3 synchronized同步方法 ####

同步方法使用的**this锁**

import java.util.concurrent.*;
    import java.util.*;
    
    public class ThreadTest implements Runnable { 
    	public synchronized void run() {  //声明方式
    		for (int i = 0; i < 5; i++) { 
    			System.out.println(Thread.currentThread().getName() + i);
    		}
    	}
    	public static void main(String[] args) { 
    		ThreadTest t = new ThreadTest();
    		Thread t1 = new Thread(t, "A");
    		Thread t2 = new Thread(t, "B");
    		t1.start();
    		t2.start();
    	}
    }
    //Output: A0 A1 A2 A3 A4 B0 B1 B2 B3 B4

要注意的是，全部对象都自己主动含有单一的锁（也称为监视器）。所以当ThreadTest对象调用synchronized方法时，此对象被加锁，这意味着。其它线程不能调用此对象的全部synchronized方法。 可是假设把一个复杂的方法声明为synchronized，会减少程序执行的效率，所以synchronized块是非常好的解决方法。  
静态同步代码块用的锁不是this锁,使用当前字节码文件

### 2. Lock和synchronized ###

ReentrantLock基于 AQS 是 java 层的锁  
synchronized 是 jvm 级别的锁  
mutex 是 OS 级别的锁  
Lock和synchronized的差别就是：  
synchronized：当A和B同一时候要訪问C资源，而A获得了对象C的锁。B将一直等待A释放对C的锁，不能被中断。  
Lock：B等待一定时间后，A还不释放C，B就会中断等待。  
它的基本使用方法：

Lock l = new ReentrantLock();
    	l.lock();
    	try { 
    	    // access the resource protected by this lock
    	} finally { 
    	    l.unlock();
    	}

从代码也能够看出，l.unlock()在finally\{\}中。这表示终于会被解锁。

### 4.死锁 ###

是指两个或两个以上的进程在执行过程中,因争夺资源而造成的一种互相等待的现象,若无外力作用,它们都将无法推进下去  
（1） 因为系统资源不足。  
（2） 进程运行推进顺序不合适。  
（3） 资源分配不当等。

死锁**四个必要条件**  
这四个条件是死锁的必要条件，只要系统发生死锁，这些条件必然成立，而只要上述条件之一不满足，就不会发生死锁。  
（1） 互斥条件：一个资源每次只能被一个进程使用。  
（2） 请求与保持条件：一个进程因请求资源而阻塞时，对已获得的资源保持不放。  
（3） 不剥夺条件:进程已获得的资源，在末使用完之前，不能强行剥夺。  
（4） 循环等待条件:若干进程之间形成一种头尾相接的循环等待资源关系。  
防止进程在处于等待状态的情况下占用资源。因此，对资源的分配要给予合理的规划。  
避免死锁破坏条件之一,最简单的方法就是线程都是以同样的顺序加锁和释放锁，也就是破坏了第四个条件。  
面试题请写出一个死锁:

public class DeadLockDemo { 
    	private static String A="A";
    	private static String B="B";
    	public static void main(String[] args){ 
    		new DeadLockDemo().deadLock();
    	} 
    	private void deadLock(){ 
    		Thread threadA=new Thread(new Runnable(){ 
    			@Override
    			public void run(){ 
    				synchronized(A){ 
    					try { 
    						Thread.currentThread().sleep(2000);
    					} catch (InterruptedException e) {  
    						e.printStackTrace();
    					}
    					synchronized(B){ 
    						System.out.println("AB");
    					}
    				}
    			}
    		});
    		Thread threadB=new Thread(new Runnable(){ 
    			@Override
    			public void run(){ 
    				synchronized(B){ 
    					try { 
    						Thread.currentThread().sleep(2000);
    					} catch (InterruptedException e) {  
    						e.printStackTrace();
    					}
    					synchronized(A){ 
    						System.out.println("BA");
    					}
    				}
    			}
    		});
    		threadA.start();
    		threadB.start();
    	}
    }

### 5. java内存模型jmm ###

java内存结构 jvm内存分配  
java内存模型:JMM决定一个线程对共享变量的写入时,能对另一个线程可见  
从抽象的角度来看，JMM定义了线程和主内存之间的抽象关系：

线程之间的共享变量存储在主内存（main memory）中，
    每个线程都有一个私有的本地内存（local memory），本地内存中存储了该线程以读/写共享变量的副本。

本地内存是JMM的一个抽象概念，并不真实存在。它涵盖了缓存，写缓冲区，寄存器以及其他的硬件和编译器优化。  
![这里写图片描述][70]  
多线程三大特性:原子性(保证线程),可见性,有序性(join,wait,notify)

### 6.volatile关键字 ###

volatile关键字，使用场景？原子性的理解？先行发生原则？  
Volatile 关键字的作用是变量在多个线程之间可见。  
不保证原子性.  
举例说明::

class ThreadVolatileDemo extends Thread { 
    	//flag变量可以设成volatile
    	public    boolean flag = true;
    	@Override
    	public void run() { 
    		System.out.println("开始执行子线程....");
    		while (flag) { 
    		}
    		System.out.println("线程停止");
    	}
    	public void setRuning(boolean flag) { 
    		this.flag = flag;
    	}
    
    }
    
    public class ThreadVolatile { 
    	public static void main(String[] args) throws InterruptedException { 
    		ThreadVolatileDemo threadVolatileDemo = new ThreadVolatileDemo();
    		threadVolatileDemo.start();
    		Thread.sleep(3000);
    		threadVolatileDemo.setRuning(false);
    		System.out.println("flag 已经设置成false");
    		Thread.sleep(1000);
    		System.out.println(threadVolatileDemo.flag);
    
    	}
    }
    //output:
    //开始执行子线程....
    //flag 已经设置成false

已经将结果设置为fasle为什么？还一直在运行呢。  
原因:线程之间是不可见的，读取的是副本，没有及时读取到主内存结果。  
解决办法使用Volatile关键字将解决线程之间可见性, 强制线程每次读取该值的时候都去“主内存”中取值  
仅靠volatile不能保证线程的安全性。（原子性）使用AtomicInteger原子类

public class VolatileNoAtomic extends Thread { 
       static int count = 0;
       private static AtomicInteger atomicInteger = new AtomicInteger(0);
    
       @Override
       public void run() { 
       	for (int i = 0; i < 1000; i++) { 
       		//等同于i++
       		atomicInteger.incrementAndGet();
       	}
       	System.out.println(count);
       }
    
       public static void main(String[] args) { 
       	// 初始化10个线程
       	VolatileNoAtomic[] volatileNoAtomic = new VolatileNoAtomic[10];
       	for (int i = 0; i < 10; i++) { 
       		// 创建
       		volatileNoAtomic[i] = new VolatileNoAtomic();
       	}
       	for (int i = 0; i < volatileNoAtomic.length; i++) { 
       		volatileNoAtomic[i].start();
       	}
       }
    
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NzYyNjc3_size_16_color_FFFFFF_t_70 1]  
https://www.cnblogs.com/dolphin0520/p/3958019.html

### 7. 乐观锁与悲观锁 ###

### 8.多线程处理Timer ###

多线程并行处理定时任务时，Timer 运行多个 TimeTask 时，只要其中之一没有捕获  
抛出的异常，其它任务便会自动终止运行，使用 ScheduledExecutorService 则没有这个问题。

### CountDownLatch ###

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

<table> 
 <tbody> 
  <tr> 
   <td><b><font>多线程出现问题如何排查</font></b></td> 
  </tr> 
 </tbody> 
</table>

1.  通过top命令查看当前系统CPU使用情况，定位CPU使用率超过100%的进程ID；
2.  通过ps aux | grep PID命令进一步确定具体的线程信息；  
    https://www.cnblogs.com/zyhxhx/p/4564953.html

[format_png]: /images/20220514/fedc61c851064cb4a3478baa9a51391c.png
[Link 1]: https://blog.csdn.net/u012403290/article/details/64910926?locationNum=11&fps=1
[Link 2]: https://www.cnblogs.com/baizhanshi/p/6419268.html
[Link 3]: https://blog.csdn.net/qq_36762677/article/details/82904121
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NzYyNjc3_size_16_color_FFFFFF_t_70]: /images/20220514/f167d93cae33462bb5ba46ad7b64a30f.png
[ImportNew.com -]: http://www.importnew.com/29562.html
[Link 4]: https://www.jianshu.com/p/94cf9ebd8932
[70]: /images/20220514/2bc4447c7b05473992356c734453ba28.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NzYyNjc3_size_16_color_FFFFFF_t_70 1]: /images/20220514/997e005107e146829e6f450a118b164a.png