【多线程奇妙屋】 Java 的 Thread类必会小技巧，教你如何用多种方式快速创建线程，学并发编程必备(实践篇)

置顶邂逅岁月

已于 2024-09-30 09:55:50 修改

阅读量409

点赞数 22

分类专栏：计算机八股文知识study 踏寻 JavaEE 之谜来杯Java式的卡布奇诺吧文章标签： java 开发语言操作系统 JavaEE 线程进程并发编程

于 2024-09-30 09:54:48 首次发布

本文链接：https://blog.csdn.net/mgzdwm/article/details/142483482

版权

来杯Java式的卡布奇诺吧同时被 3 个专栏收录

28 篇文章 3 订阅

订阅专栏

计算机八股文知识study

16 篇文章 0 订阅

订阅专栏

踏寻 JavaEE 之谜

15 篇文章 0 订阅

订阅专栏

本篇会加入个人的所谓鱼式疯言

❤️❤️❤️鱼式疯言:❤️❤️❤️此疯言非彼疯言

而是理解过并总结出来通俗易懂的大白话,

小编会尽可能的在每个概念后插入鱼式疯言,帮助大家理解的.

🤭🤭🤭可能说的不是那么严谨.但小编初心是能让更多人能接受我们这个概念！！！

在这里插入图片描述

前言

想象一下，如果你的电脑只能一次执行一个任务，那会是多么的低效。幸运的是，Java提供了一种强大的机制，允许程序同时执行多个任务。这就是我们今天要探讨的主题——Java中的Thread类。

一. Thread 类

1. Thread 类的初识

对于线程的概念，本身是 操作系统内核提出的概念 。

如果要执行并发编程，就需要掌握不同的系统 api (例如 window 系统api ， Linux 系统api ) 等… 这种 不同系统的api 是不一样的。

对于我们 Java程序猿来说， Java的api 早已分装好 对应的系统api ，我们这只需要学习 Java的api 即可。

而进行并发编程的 Java最重要的api 就是标准库中 Thread 类。

通过这个类，我们可以实现对于 线程的创建 ，以及利用每个线程进行 业务逻辑和任务 的执行。

鱼式疯言

并且 Thread 是 java.lang 下面的一个库，是不需要手动导包的。

二. 创建线程的方式

1. 创建线程

<1>. 代码展示

/**
 * 创建线程：
 * 继承 Thread
 * 重写 run 方法
 */

public class MyThread extends Thread{


    @Override
    public void run() {
        while (true) {
            System.out.println("MyThread的run线程 正在运行...");
            try {
                MyThread.sleep(10000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MyThread myThread =new MyThread();

        // 创建一个线程
        myThread.start();

        // 主方法
        while (true) {

            System.out.println("main线程 正在运行...");
            MyThread.sleep(10000);
        }

    }
}

在这里插入图片描述

<2>. 创建流程

首先创建一个先继承Thread 类，并重写 run 方法
在 main 方法 中 实例化一个 MyThread 类 。
调用start() 方法来创建线程，并执行run 方法里面的业务逻辑。

鱼式疯言

补充总结：

由于我们在执行程序时，系统就会分配资源，自动创建进程，并且程序是需要 调度执行 ，所以 main 方法自身就是一个线程： 主线程

所以上述过程中，可以认为在 主线程 中又 创建了一个线程 。

<3>. 逻辑分析

run 中写着的是这个线程需要执行的 各种代码逻辑 ，相当于在 main方法 中的 代码同等含义。

虽然在上述代码中， 没有直接调用重写的run 方法 ，但是当我们调用 start（） 方法后，在 Java代码中会重新调用我们重写的 run 方法。

如果只是单纯的调用 run 方法 ，并不能创建线程。

对于上述过程有两个线程： 主线程 和 myThread ，都是分布在同一个系统资源下的，所以需要 并发执行 : 两个死循环都 不会相互制约 ，各自执行各自的。 抢占执行: 不能确定是哪个线程先执行到对应的逻辑。

鱼式疯言

补充细节 ：

上诉代码中，我们用到了 sleep() 方法，这个方法是 Thread 中的静态方法 （类方法） 。可以让程序 休眠一段时间 ，调用这个目的：就是让程序猿好观察程序的执行过程。

() 内参数 指定的是多少 毫秒（ms） ，用于 指定休眠多少时间 ，其中 1000 ms = 1s 换算进制。

调用sleep（）和 创建线程的过程 ，都是需要抛出： InterruptedException 这个异常的

2. 创建线程的其他方式

对于创建线程的方式：

除了上述继承 Thread 重写run方法 之外还有其他常见四种方式

实现 Runnable 接口，重写 run 方法；
使用匿名内部类，对 Thread 类 重写 run 方法 ；
使用匿名内部类，实现 Runnable 接口 重写run 方法 ；
使用 lambda 表达式，对 匿名内部类 进行简化。

<1>. 实现 Runnable 接口

/**
 * 方法二：
 * 继承 Runnable
 * 实现 run 方法
 *
 */


class  MyThread1 implements  Runnable {

    @Override
    public void run() {
        while (true) {
            System.out.println("Runnable 中run线程 正在运行...");
            try {
                MyThread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {


        Thread myThread1 = new Thread(new MyThread1());
        myThread1.start();

        // 接口
        while (true) {
            System.out.println("main线程 正在运行");
            MyThread.sleep(1000);
        }


    }
}

在这里插入图片描述

对于这种方式的实现

主要的流程还是在实例化Thread 对象之前：

首先创建一个类 MyThread1 用于 实现 Runnable 接口

重写 run 方法

最终 new出对象 MyThread1 作为 Thread（）的参数 进行传入进行实例化Thread 对象即可。

后面的过程就和上面相同了，小编在这里就不赘述了 💖💖🦊🦊🦊🦊

<2>. 匿名内部类—— 重写 Thread 的 run 方法

/**
 *
 * 方法四： Thread 的匿名内部类
 * 在匿名内部类中重写 Run 方法
 *
 */


class  MyThread3 {
    public static void main(String[] args) throws InterruptedException {

        Thread myThread3 = new Thread(){

            @Override
            public void run() {
                while (true) {
                    System.out.println("匿名类 MyThread的run线程 正在运行...");
                    try {
                        MyThread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        };

        // 创建线程
        myThread3.start();

        // 输出主线程
        while (true) {
            System.out.println("main 线程正在运行...");
            MyThread.sleep(1000);
        }
    }
}

在这里插入图片描述

我们知道，对于 匿名内部类 来说，是一种不带引用的一种对象，也就是说当

实例化 Thread 类对象时，我们使用匿名内部类的方式就是在 Thread () 后面加上 { } ，并在{ } 内部 重写 run 方法 。

以上就是唯一的区别，其他操作都一样。

<3>. 匿名内部类 —— 实现 Runnable 接口的 run 方法




/**
* 方法三 : Runnable 的匿名内部类
* 在匿名内部类中 实现 Run 方法
*
*/

class  MyThread2 {
   public static void main(String[] args) {
       Thread myThread2 = new Thread(new Runnable() {
           @Override
           public void run() {
               while (true) {
                   System.out.println("内部类Runnable 中 Run方法正在执行...");
                   try {
                       MyThread.sleep(1000);
                   } catch (InterruptedException e) {
                       throw new RuntimeException(e);
                   }
               }
           }

       });

       // 创建线程
       myThread2.start();

       while (true) {
           System.out.println("主线程方法正在调用....");
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {

               throw new RuntimeException(e);

           }
       }


   }
}

在这里插入图片描述

对于 匿名内部类 而已，使用的方式和 上面一种方式相同 ，而在这里唯一的区别就在于，上面 new 出了 new Runnable 作为参数进行传入到 Thread 对象中。

而本方式中，则是在 Thread 后面 直接 重写 run 方法 。

<4>. 使用 lambda 表达式简化匿名内部类

/**
 * 方法五：  使用 lambda 表达式简化 匿名内部类
 *
 */
 

class  MyThread4 {

    public static void main(String[] args) throws InterruptedException {

        Thread myThread4 = new Thread(()->{
            while (true) {
                System.out.println("lambda 匿名类 MyThread的run线程 正在运行...");
                try {
                    MyThread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });

        // 创建线程
        myThread4.start();

        // 输出主线程
        while (true) {
            System.out.println("main 线程正在运行...");
            MyThread.sleep(1000);
        }
    }
}

在这里插入图片描述

对于 lambda 表达式来说，

最核心的部分就是：

把 new Runnable() {} 就是简化成 （）-> {} 来使用，其实本质上还是通过 匿名内部类 实现 Runnable 接口 的一种简化版本。

鱼式疯言

对于 lambda 表达的使用，一定要注意一点的是：必须是 函数式接口 ，也就是只有一个抽象方法的接口才能使用 lambda 。

对于 start 创建线程 来说，当调用 start 方法后， 系统内核会生成 PCB 并且添加链表，创建新的线程。所以当多次调用 start 方法时，就会抛出异常，因为对于一个Thread 对象来说，只能start 一次，也就是说 只能创建一个线程 ，这个原因也是为了 JVM 方便管理 ，否则一个Thread 对象对应多个线程就会管理起来很复杂。

在这里插入图片描述

例如上述过程，就会 抛出异常 : IllegalThreadStateException

上述总共 五种创建线程 的方式，都是蛮重要的，小伙伴们务必多操练多熟悉里面的 代码流程和逻辑 哦~

三. 线程终止

1. 线程终止的初识

线程终止的方式有很多种终止的方式，有粗暴的，也有温柔的。

像粗暴的：让执行到一半的线程直接终止

像温柔的：让 线程执行完整个任务 才终止

对于Java 来说，我们是下面这种方式，让线程执行完所有的任务才终止。

下面就让我们来瞧瞧呗 ❣️ ❣️ ❣️ ❣️

2. Java线程终止的简易版

public class MyThread1 {
   public static boolean state = true;
    public static void main(String[] args) throws InterruptedException {

        Thread t  = new Thread(() -> {
            while(state) {
                System.out.println("hello Thread1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });


//        创建线程
            t.start();
        Thread.sleep(3000);
        state = false;

    }
}

在这里插入图片描述

对于上述的流程主要是：

首先定义一个布尔变量，用来确定线程的状态为 true 线程正在运行，为 false 线程结束 。
其次在主线程中修改 线程状态，让线程结束。注意这种结束的方式是让线程中的 任务都执行结束 了，当需要再次执行任务的时候才 置为 false 的 ，是一种比较温柔的做法。

鱼式疯言

补充细节 ：

在这里插入图片描述

入上图，如果把布尔类型放在 main 方法的内部呢？

其实就会有问题，这归咎于我们的Java语法中有个小知识点： 变量捕获

其实这种变量捕获是对于 lambda 表达式 来说的，如果要在 lambda 表达式 中使用 同一作用域下的变量 ，这个变量是不可以被修改的。

也就是说在上面的 state = false 出现了修改，所以 lambda 中就会编译失败。

那么出现这种问题的比较好的解决方案就是把这个变量定义为成员变量，这样 两种的作用域就不相同 了，也从另外一个角度来看，内部的方法调用外部的成员是没有问题的，天经地义的

3. Java 自身的线程终止方法

class Thread2 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            // 先获取当前线程
            Thread currentThread = Thread.currentThread();

//            判断线程状态
            while(!currentThread.isInterrupted()) {
                System.out.println("hello thread1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    break;
                }
            }
        });

//        创建线程
        t.start();
        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

//        修改线程状态
        t.interrupt();

    }
}

在这里插入图片描述

上述代码的流程主要分为以下几步：

实例化Thread对象，在 run方法中使用 currentThread 方法 来获取当前线程

获取当前线程后 ，使用 isInterrupted 判断当前线程的状态，自身返回 false 代表 线程正在进行， true 代表线程结束。

创建线程，并 休眠指定时间 ，使用 interrupted 来修改 isInterrupted 为 true，让线程终止。

在 try catch{ } 在 catch 中添加 break ，直接跳出循环。

4. 代码分析

对于上述代码小编还有很多话想和小伙伴们唠唠，因为我个人觉得还是比较重要的，小伙伴们可不要嫌我烦哦~ 🍖 🍖 🍖 🍖

如果 catch 中不添加 break ，而是按照平常的写法： throw new RuntimeException(e); 直接抛出新的异常呢？

在这里插入图片描述

情况就会变成这样，原因很简单，对于线程执行的时间来说，大部分时间是处于 sleep 的休眠状态，一旦有 外面的线程来修改线程的状态 ， sleep 就会 被打破休眠的状态 ，这时就会 抛出异常，这时被 try catch { } 捕获到，就会执行 throw new RuntimeException(e); 抛出新的异常，由于这个 异常没有及时处理 ，编译器就会自动交给 JVM 来处理。所以我们不需要在 catch { } 写 throw new RuntimeException(e);的方法。