多线程重点知识归纳总结。

太过爱你忘了你带给我的痛 2023-10-02 19:39 13阅读 0赞

**目录**

一、线程相关概念

1、程序

2、进程

3、线程

2、多线程应用

1、创建线程的两种方式

2、代码示例

三、Runnable 接口

1、为什么要实现接口

2、代码示例：如何使用

3、静态代理模式：模拟极简的Tread类

4、继承Tread类 和 实现Runnable接口的区别

四、线程常用方法

1、补充-线程终止

2、常用方法

3、守护线程

五、线程的生命周期

1、线程的几种状态

2、线程状态转换图

3、代码示例：查看线程状态

六、线程同步机制

1、基本介绍

2、synchronized 关键字

3、互斥锁

4、线程死锁

5、释放锁

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

## 一、线程相关概念 ##

> ### 1、程序 ###
> 
>  程序是一个指令序列。是为完成特定任务、 用某种语言编写的一组指令的集合。简单的说:就是我们写的代码
> 
>  它以某些程序设计语言编写，运行于某种目标结构体系上。打个比方，程序就如同以英语（程序设计语言）写作的文章，要让一个懂得英语的人（编译器）同时也会阅读这篇文章的人（结构体系）来阅读、理解、标记这篇文章。一般的，以英语文本为基础的计算机程序要经过编译、链接而成为人难以解读，但可轻易被计算机所解读的数字格式，然后放入运行。
> 
> ### 2、进程 ###
> 
> 进程是指运行中的程序, 比如我们使用QQ，就启动了一个进程，操作系统就会为该进程分配内存空间。 当我们使用迅雷，又启动了一个进程，操作系统将为迅雷分配新的内存空间。  
> 进程是程序的一次执行过程，或是正在运行的一个程序。是动态过程 : 有它自身的产生 存在和消亡的过程
> 
> ### 3、线程 ###
> 
> **（1）基本介绍**
> 
> **线程是操作系统能够进行运算调度的最小单位。**它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。
> 
> 线程是独立调度和分派的基本单位。线程可以为操作系统内核调度的内核线程，如Win32线程；由用户进程自行调度的用户线程，如Linux平台的POSIX Thread；或者由内核与用户进程，如Windows 7的线程，进行混合调度。
> 
> **一个进程可以有很多线程，每条线程并行执行不同。**
> 
> 同一进程中的多条线程将共享该进程中的全部系统资源，如虚拟地址空间，文件描述符和信号处理等等。但同一进程中的多个线程有各自的调用栈（call stack），自己的寄存器环境（register context），自己的线程本地存储（thread-local storage）。
> 
> **（2）单线程**
> 
> 同一个时刻， 只允许执行一个线程。（单线程在程序执行时，所走的程序路径按照连续顺序排下来，前面的必须处理好，后面的才会执行。）
> 
> **（3）多线程**
> 
> 同一个时刻， 可以执行多个线程，比如 : 一个qq进程, 可以同时打开多个天窗口，一个迅需进程， 可以同时下载多个文件
> 
> **（4）并发**
> 
> 同一个时刻，多个任务交替执行，造成一种“貌似同时” 的错觉， 简单的说， 单核cpu实现的多任务就是井发。
> 
> **（5）并行**
> 
> 同一个时刻，多个任务同时执行。多核cpu可以实现并行。

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

## 2、多线程应用 ##

> ### 1、创建线程的两种方式 ###
> 
> （1）继承 Thread 类，重写 run 方法
> 
> （2）实现 Runnable 接口，重写 run 方法
> 
> （3）Thread 类示意图：
> 
> ![dedb030aee754c13ad44d65030d348c5.png][]
> 
> ### 2、代码示例 ###
> 
> ▶ 当一个类继承了 Thread 类， 该类就可以当做线程使用 
> 
> ▶ 我们会重写 run 方法，写上自己的业务代码
> 
> public class Thread01 {
> public static void main(String[] args) throws InterruptedException{//抛出异常
> 
> //创建一个Cat对象，当线程使用
> Cat cat = new Cat();
> //启动线程
> cat.start();
> 
> //当主线程（main）启动一个子线程（Thread-0） ,主线程不会阻塞（即停止），会继续执行
> //这时主线程和子线程是交替执行的（交替速度极快）
> //Thread.currentThread().getName() 获取线程的名称
> System.out.println("主线程继续执行" + Thread.currentThread().getName());
> 
> for (int i = 0; i < 60; i++){
> 
> System.out.println("主线程 i=" + i);
> 
> //让主线程休眠
> Thread.sleep(1000);
> 
> }
> }
> }
> 
> //当一个类继承了 Thread类，该类就可以当做线程使用
> //我们会重写run方法，写上自己的业务代码
> class Cat extends Thread{
> 
> //记录次数，为了控制退出线程
> int times = 0;
> 
> @Override
> public void run() {
> 
> while (true) {
> 
> //该线程每隔一秒，在控制台输出子线程
> System.out.println("子线程 ：" + (++times) + "线程名=" + Thread.currentThread().getName());
> 
> //让该线程休眠一秒
> //此处有异常，需要try-catch
> try {
> Thread.sleep(1000);
> } catch (InterruptedException e) {
> e.printStackTrace();
> }
> 
> //退出线程
> if (times == 80){
> break;//当times到80时，线程就退出了
> }
> 
> }
> }
> }
> 
> 3、底层
> 
> ![6b2440595c2549e09f25af6443db4d26.jpeg][]

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

## 三、Runnable 接口 ##

> ### 1、为什么要实现接口 ###
> 
>  *  java是单继承的，在某些情况下一个类可能已经继承了某个父类，这时再用继承Thread类方法来创建线程显然不可能了。
>  *  java设计者们提供了另外一个方式创建线程，就是通过实现 Runnable 接口来创建线程
> 
> ### 2、代码示例：如何使用 ###
> 
>     public class Runnable01 {
>         public static void main(String[] args) {
>     
>             Text text = new Text();
>     
>             //一定要注意：这里不能直接调用start()
>     
>             //需要创建Thread对象，把text对象(实现Runnable)放入到Thread
>             Thread thread = new Thread(text);
>     
>             //然后再调用 start()方法
>             thread.start();
>     
>         }
>     }
>     
>     // Text类 实现 Runnable 接口
>     class Text implements Runnable {
>     
>         //计数
>         int count = 0;
>     
>         @Override
>         public void run() {//普通方法
>     
>             while (true) {
>     
>                 System.out.println("hi" + (++count) + Thread.currentThread().getName());
>     
>                 try {//休眠1秒，有异常进行try-catch
>     
>                     Thread.sleep(1000);
>     
>                 } catch (InterruptedException e) {
>     
>                     e.printStackTrace();
>     
>                 }
>                     
>                 //退出线程
>                 if (count == 10) {
>                     break;
>                 }
>     
>             }
>     
>         }
>     }
> 
> ### 3、静态代理模式：模拟极简的Tread类 ###
> 
>     public class Runnable01 {
>         public static void main(String[] args) {
>     
>             //创建T1对象
>             T1 t1 = new T1();
>     
>             //创建ThreadProxy 对象，参数是t1对象
>             ThreadProxy threadProxy = new ThreadProxy(t1);
>             
>             //启动线程，调用start()方法
>             threadProxy.start();
>         }
>     }
>     
>     
>     class T {
>     
>     }
>     
>     class T1 extends T implements Runnable {
>     
>         @Override
>         public void run() {
>             System.out.println("T1类");
>         }
>     
>     }
>     
>     //静态代理模式
>     //模拟了一个极简的Thread类
>     class ThreadProxy implements Runnable {
>     
>         //属性，类型是 Runnable
>         private Runnable target = null; 
>     
>         //构造器
>         public ThreadProxy(Runnable target) {
>             this.target = target;
>         }
>     
>     
>         //start()方法
>         public void start() {
>             
>             //调用start0()方法
>             start0();
>         }
>     
>         //start0()方法
>         public void start0() {
>             
>             //调用run方法
>             run();
>         }
>     
>         @Override
>         public void run() {
>     
>             if (target != null) {
>                 target.run();  //动态绑定（运行类型T1）
>             }
>     
>         }
>     }
> 
> **运行顺序：**
> 
> ThreadProxy对象的start()方法 **-->** start0()方法 **-->** ThreadProxy对象的run() 方法 **-->** 创建ThreadProxy对象时，传入了t1对象，所以target 不为空 **-->** 运行类型是传入是t1对象，所以会调用 T1类 的 run()方法
> 
> ### 4、继承Tread类 和 实现Runnable接口的区别 ###
> 
>  *  从java的设计来看， 通过继承Thread或者实现Runnable接口来创建线程本质上没有区别，从jdk文档中我们可以知道Thread类本身就实现了Runnable接口
>  *  实现Runnable接口方式更加适合多个线程共享一个资源的情况 并且避免了单继承的限制，建议使用Runnable

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

## 四、线程常用方法 ##

> ### 1、补充-线程终止 ###
> 
> * 线程终止就是当线程完成任务后，会自动退出。
> * 还可以通过使用变量来控制 run方法 退出的方式停止线程，即通知方式
> * 代码示例
> 
> public class Exit_ {
> public static void main(String[] args) throws InterruptedException{
> T t = new T();
> t.start();
> 
> //通知方式
> 
> //让主线程休眠10秒
> Thread.sleep(10 * 1000);
> 
> //如果希望main线程去控制t 线程的终止，只需要修改loop
> //修改loop的值为false 让t退出run方法，而终止t线程
> t.setLoop(false);
> }
> }
> 
> class T extends Thread{
> 
> //计数
> int count = 0;
> 
> //设置一个控制变量，控制线程的退出
> private boolean loop = true;
> 
> @Override
> public void run() {
> 
> while (loop){
> try {
> Thread.sleep(50);
> } catch (InterruptedException e) {
> e.printStackTrace();
> }
> 
> System.out.println("线程正在运行...." + (++count));
> 
> }
> }
> 
> //用来修改 loop 属性
> public void setLoop(boolean loop){
> this.loop = loop;
> }
> }
> 
> ### 2、常用方法 ###
> 
> <table style="width:626px;"> 
> <thead> 
> <tr> 
> <th>方法名</th> 
> <th style="width:337px;">功能</th> 
> </tr> 
> </thead> 
> <tbody> 
> <tr> 
> <td>setName</td> 
> <td style="width:337px;">设置线程称</td> 
> </tr> 
> <tr> 
> <td>getName</td> 
> <td style="width:337px;">返回该线程的名称，使之与参数name相同</td> 
> </tr> 
> <tr> 
> <td>start</td> 
> <td style="width:337px;">使该线程开始执行，即启动线程，Java 虚拟机底层调用该线程的start0方法。注意：底层会创建新的线程，调用run方法，run方法就是一个简单的方法调用，不会启动新线程</td> 
> </tr> 
> <tr> 
> <td>run</td> 
> <td style="width:337px;">调用线程对象 run方法</td> 
> </tr> 
> <tr> 
> <td>setPriority</td> 
> <td style="width:337px;">更改线程的优先级</td> 
> </tr> 
> <tr> 
> <td>getPriority</td> 
> <td style="width:337px;">获取线程的优先级</td> 
> </tr> 
> <tr> 
> <td>sleep</td> 
> <td style="width:337px;">在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)，（线程的静态方法）</td> 
> </tr> 
> <tr> 
> <td>interrupt</td> 
> <td style="width:337px;">中断线程。注意中断线程, 是没有真正的结束线程的。所以一般用于中断正在休眠线程</td> 
> </tr> 
> <tr> 
> <td>yield</td> 
> <td style="width:337px;">线程的礼让。 让出cpu, 让其他线程执行，但礼让的时间不确定 所以也不一定礼让成功</td> 
> </tr> 
> <tr> 
> <td>join</td> 
> <td style="width:337px;">线程的插队。 插队的线程一旦插队成功，则肯定先执行完插入的线程的所有任务，然后再依次执行其他任务</td> 
> </tr> 
> </tbody> 
> </table>
> 
> **join ：线程插队代码示例**
> 
> public class Method02 {
> public static void main(String[] args) throws InterruptedException{
> T2 t2 = new T2();
> t2.start();
> 
> for (int i = 1; i <= 20; i++) {
> Thread.sleep(1000);
> System.out.println("主线程执行...." + i);
> 
> if (i == 5){
> System.out.println("主线程让子线程先执行");
> //join --> 线程插队
> t2.join();
> System.out.println("子线程执行完，主线程继续执行");
> }
> }
> }
> }
> class T2 extends Thread{
> 
> @Override
> public void run() {
> 
> for(int i = 1;i <= 20; i++){
> 
> try {
> Thread.sleep(1000);
> } catch (InterruptedException e) {
> e.printStackTrace();
> }
> 
> System.out.println("子线程在执行...." + i);
> 
> }
> 
> }
> 
> }
> 
> **解释：**主线程和子线程会先交替执行，当 i = 5 时子线程会线程插队，然后只执行子线程，当子线程执行完毕，再继续执行主线程。
> 
> ### 3、守护线程 ###
> 
> * 用户线程 : 也叫工作线程，当线程的任务执行完毕或通知的方式结束
> * 守护线程 : 一般是为工作线程服务的，当所有的用户线程结束，守护线程自动结束
> * 常见的守护线程 : 垃圾回收机制
> * 代码示例：
> 
> public class Method03 {
> public static void main(String[] args) throws InterruptedException{
> 
> MyDaemonThread myDaemonThread = new MyDaemonThread();
> 
> //如果我们希望主线程结束后，子线程自动结束，只需将子线程设置成守护线程即可
> myDaemonThread.setDaemon(true);
> 
> myDaemonThread.start();
> 
> 
> 
> for (int i = 1; i <= 10; i++) {
> System.out.println("主线程在执行....");
> Thread.sleep(1000);
> }
> }
> }
> class MyDaemonThread extends Thread{
> @Override
> public void run() {
> 
> //无限循环
> for (; ;) {
> 
> try {
> Thread.sleep(1000);
> } catch (InterruptedException e) {
> e.printStackTrace();
> }
> 
> System.out.println("子线程在执行....");
> }
> 
> }
> }
> 
> **关键点：**在启动线程之前，把 setDaemon()方法设置成 true

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

## 五、线程的生命周期 ##

> ### 1、线程的几种状态 ###
> 
> ![aa68d83e776240bc89f73b20def747c7.png][]
> 
> ### 2、线程状态转换图 ###
> 
> ![89623d3776494553b2156b3a0c23410d.jpeg][]
> 
> ### 3、代码示例：查看线程状态 ###
> 
> public class State {
> public static void main(String[] args) throws InterruptedException{
> 
> T t = new T();
> 
> //查看初始状态，调用方法getState()
> System.out.println(t.getName() + " 状态" + t.getState());
> 
> //启动线程
> t.start();
> 
> //循环查看线程的状态
> while (Thread.State.TERMINATED != t.getState()){
> 
> System.out.println(t.getName() + " 状态" + t.getState());
> 
> Thread.sleep(500);
> 
> }
> 
> System.out.println(t.getName() + " 状态" + t.getState());
> }
> }
> class T extends Thread{
> @Override
> public void run() {
> 
> while (true){
> 
> for (int i = 0; i < 10; i++) {
> System.out.println("hi " + i);
> try {
> Thread.sleep(1000);
> } catch (InterruptedException e) {
> e.printStackTrace();
> }
> }
> 
> break;
> }
> 
> }
> 
> }

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

## 六、线程同步机制 ##

> ### 1、基本介绍 ###
> 
> * 在多线程编程时，一些敏感数据不允许被多个线程同时访问，此时就使用同步访问技术保证数据在任何时刻，最多有一个线程访问，以保证数据的完整性。
> * 也可以这样理解 : 线程同步, 即当有一个线程在对内存进行操作时, 其他线程都不可以对这个内存地址进行操作，直到该线程完成操作， 其他线程才能对该内存地址进行操作
> 
> ### 2、synchronized 关键字 ###
> 
> **（1）同步代码块** 
> synchronized (对象)\{//得到对象的锁，才能操作同步代码
> 
> //需要被同步代码
> 
> \} 
> **（2）同步方法**
> 
> public synchronized void m1(String name)\{
> 
> //需要被同步的代码
> 
> \}
> 
> ### 3、互斥锁 ###
> 
> **（1）基本介绍**
> 
> * Java语言中，引入了对象互斤锁的概念， 来保证共享数据操作的完整性。
> * 每个对象都对应于一个可称为“互斥锁”的标记，这个标记用来保证在任一时刻，只能有一个线程访问该对象。
> * 关键字synchronized 来与对象的互斥锁联系。 当某个对象用 synchronized 修饰时,表明该对象在任一时刻只能由一个线程访问。
> * 同步的局限性 : 导致程序的执行效率要降低
> * 同步方法(非静态的）的锁可以是this, 也可以是其他对象(要求是同一个对象)
> * 同步方法 (静态的）的锁为当前类本身。
> 
> **（2）注意事项**
> 
> * 同步方法如果没有使用static修饰 : 默认锁对象为this 
> * 如果方法使用static修饰, 默认锁对象 ：当前类.class
> * 实现的落地步骤 : ①需要先分析上锁的代码 ②选择同步代码块或同步方法 ③要求多个线程的锁对象为同一个即可!
> 
> **（3）代码示例**
> 
> public class SellTicket {
> public static void main(String[] args) {
> 
> SellTicket03 sellTicket03 = new SellTicket03();
> 
> new Thread(sellTicket03).start();
> new Thread(sellTicket03).start();
> new Thread(sellTicket03).start();
> }
> }
> 
> //使用Runnable方式
> class SellTicket03 implements Runnable{
> 
> //控制线程退出
> boolean loop = true;
> 
> private static int ticketNum = 100; //让多个线程共享ticketnum
> 
> //在同一时刻只能有一个线程来执行sell方法，加synchronized关键字
> public synchronized void sell(){
> if (ticketNum <= 0){
> System.out.println("售票结束。。。");
> loop=false;
> return;
> }
> 
> System.out.println("剩余票数" + (--ticketNum));
> }
> 
> @Override
> public void run() {
> 
> while (loop){
> try {
> Thread.sleep(100);
> } catch (InterruptedException e) {
> e.printStackTrace();
> }
> //调用方法，实现售票
> sell();
> }
> 
> }
> }
> 
> ### 4、线程死锁 ###
> 
> * 多个线程都占用了对方的锁资源，但不肯相让，导致了死锁，在编程是一定要避免死锁的发生。
> 
> ### 5、释放锁 ###
> 
> * 当前线程的同步方法、 同步代码块执行结束。就会释放锁
> * 当前线程在同步代码块、 同步方法中遇到break，return。就会释放锁
> * 当前线程在同步代码块、同步方法中出现了未处理的Error 或 Exception，导致异常结束。就会释放锁
> * 当前线程在同步代码块、 同步方法中执行了线程对象的 wait()方法, 当前线程暂停，并释放锁
> * 线程执行同步代码块或同步方法时，程序调用Thread.sleep()、Thread.yield()方 
> 法暂停当前线程的执行，不会释放锁
> * 线程执行同步代码块时，其他线程调用了该线程的suspend()方法将该线程挂起， 
> 该线程不会释放锁
> * 注意：应尽量避免使用suspend()和resume()来控制线程， 方法不再推荐使用

[dedb030aee754c13ad44d65030d348c5.png]: https://img-blog.csdnimg.cn/dedb030aee754c13ad44d65030d348c5.png
[6b2440595c2549e09f25af6443db4d26.jpeg]: https://img-blog.csdnimg.cn/6b2440595c2549e09f25af6443db4d26.jpeg
[aa68d83e776240bc89f73b20def747c7.png]: https://img-blog.csdnimg.cn/aa68d83e776240bc89f73b20def747c7.png
[89623d3776494553b2156b3a0c23410d.jpeg]: https://img-blog.csdnimg.cn/89623d3776494553b2156b3a0c23410d.jpeg