【Java多线程】Thread类的基本用法

谁借莪１个温暖的怀抱￠ 2024-04-20 11:47 16阅读 0赞

**目录**

Thread类

1、创建线程

1.1、继承 Thread，重写run

1.2、实现 Runnable，重写run

1.3、使用匿名内部类，继承 Thread，重写run

1.4、使用匿名内部类，实现 Runnable，重写run

1.5、使用 lambda 表达式（最常用）

2、终止线程

2.1、通过共享的标记来进行沟通

2.2、调用 interrupt() 方法来通知

3、等待线程

4、获取线程实例

![9696376d33b44045866ace87d897a1cd.gif][]

## Thread类 ##

![e3b4a9a704e64c4f9a6e032f3342bb98.png][]

![e3e0799a3dcd4d98b1a8029a1d5667ac.png][]

## 1、创建线程 ##

线程的创建方法一共有五种，其中**lambda表达式**的创建方式最为常用，这里简单的给大家介绍一下这五种创建。

### 1.1、继承 Thread，重写run ###

class MyThread2 extends Thread {   //创建一个类继承Thread，并重写run
        @Override
        public void run() {   
            System.out.println("hello thread");
        }
    }
    
    public class ThreadDemo2 {
        public static void main(String[] args) {
            Thread t = new MyThread2();   //创建MyThread类的实例
            t.start();   //调用start方法启动线程
        }
    }

### 1.2、实现 Runnable，重写run ###

> Thread(Runnable target)，使用runnable对象创建线程对象。

class MyThread3 implements Runnable {   //实现Runnable接口
        @Override
        public void run() {
            System.out.println("hello runnable");
        }
    }
    
    public class ThreadDemo3 {
        public static void main(String[] args) {
            Runnable runnable = new MyThread3();  //创建runnable对象
            Thread t = new Thread(runnable);   //将runnable对象作为target参数
            t.start();   //start启动线程
        }
    }

### 1.3、使用匿名内部类，继承 Thread，重写run ###

public class ThreadDemo4 {
        public static void main(String[] args) {
            Thread t = new Thread() {   //继承thread类的匿名内部类
                @Override
                public void run() {
                    System.out.println("hello thread");
                }
            };
            t.start();
        }
    }

### 1.4、使用匿名内部类，实现 Runnable，重写run ###

public class ThreadDemo5 {
        public static void main(String[] args) {
            Thread t = new Thread(new Runnable() {   //实现Runnable接口的匿名内部类
                @Override
                public void run() {
                    System.out.println("hello runnable");
                }
            });
            t.start();
        }
    }

### 1.5、使用 lambda 表达式（最常用） ###

public class ThreadDemo6 {
        public static void main(String[] args) {
            Thread t = new Thread(() -> {   //实现Runnable接口重写run的lambda写法【推荐使用】
                System.out.println("hello thread");
            });
            t.start();
        }
    }

## 2、终止线程 ##

> 有时我们需要让正在执行的线程终止，为了让线程能够停止，需要添加一些机制。

### 2.1、通过共享的标记来进行沟通 ###

public class ThreadInterrupt {
            
        public static boolean isQuit = false;   //设置标志位isQuit充当控制开关
    
        public static void main(String[] args) throws InterruptedException {
            Thread t = new Thread(() -> {
                while (!isQuit) {    //控制while终止
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);   //让每个打印间隔1秒
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("线程执行完毕");
            });
            t.start();
            Thread.sleep(3000);   //sleep睡眠3秒后再修改标志位
            isQuit = true;
        }
    }

### 2.2、调用 interrupt() 方法来通知 ###

> 使用 **Thread.interrupted()** 或者 **Thread.currentThread().isInterrupted()** 代替自定义标识位。
> 
> 其中，**Thread.currentThread()** 表示**获取当前线程实例**，类似于 **this** 。而这里没有直接使用this是因为此处的Thread线程使用的是匿名内部类，无法通过this获取当前实例。
> 
> 最后使用 **interrupt()** 进行终止线程。

public static void main(String[] args) throws InterruptedException {
            Thread t = new Thread(() -> {
                while (!Thread.currentThread().isInterrupted()) {
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);   //让每个打印间隔1秒
                    } catch (InterruptedException e) {
                        break;   //注意此处需要添加break，因为sleep会清空interrupted标志位
                    }
                }
                System.out.println("线程执行完毕");
            });
            t.start();
            Thread.sleep(3000);   //sleep睡眠3秒后再调用interrupt终止线程
            t.interrupt();
        }

## 3、等待线程 ##

多个线程的执行顺序是不确定的**（随机调度，抢占式执行）**

虽然线程底层的调度是随机的，但是可以在应用程序中，通过一些api，来影响到线程的调度顺序使用join就是其中一种方式，**join()方法可以确定线程的结束顺序。**

![61ff7d2b0aed4e439b0991a166446a3b.png][]

public static void main(String[] args) {
            Thread t1 = new Thread(() -> {   
                System.out.println("hello thread1");
            });
            Thread t2 = new Thread(() -> {   
                System.out.println("hello thread2");
            });
            t1.start();   //此时t1线程开始执行
            t1.join();    //等待t1结束后再执行下面代码
    
            t2.start();   //此时t2线程开始执行
            t2.join();    //等待t2结束后再执行下面代码
            System.out.println("hello main");   //最后执行main主线程中的打印
        }

> **【谁调用，谁等待】main方法中调用t.join()，main主线程就阻塞等待t线程结束，再继续执行。**
> 
> **典型的使用场景：**  
> 使用多个线程并发进行一系列计算，用一个线程阻塞等待上述计算线程，等到所有的线程都计算完了，最终这个线程汇总结果。

## 4、获取线程实例 ##

> 有两种获取线程实例的方法，一种是 **this** ，另一种是 **Thread.currentThread()** 。
> 
> 其中需要注意的是：this不能使用到匿名内部类中，因此匿名内部类只能通过Thread.currentThread() 来获取实例。

class MyThread extends Thread {
        @Override
        public void run() {
            System.out.println("MyThread :"+this.getName());   //使用this直接获取实例
        }
    }
    public class GetThread {
        public static void main(String[] args) throws InterruptedException {
            Thread t1 = new Thread(() -> {
                Thread thread = Thread.currentThread();   //匿名内部类中通过currentThread获取实例
                System.out.println("t1线程中: "+thread.getName());
    
            });
            Thread t2 = new MyThread();
            
            t1.start();
            t1.join();
            
            t2.start();
        }
    }

![9beb7bb0cf994c4b92ea5484f67d5e9e.png][]

![dee5871aa3c7418b9ba59f7a73db3cf8.gif][]

**【博主推荐】**

[对进程与线程的理解-CSDN博客![icon-default.png?t=N7T8][icon-default.png_t_N7T8]https://blog.csdn.net/zzzzzhxxx/article/details/136115808?spm=1001.2014.3001.5501][-CSDN_icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_zzzzzhxxx_article_details_136115808_spm_1001.2014.3001.5501][【数据结构】二叉树的三种遍历（非递归讲解）-CSDN博客![icon-default.png?t=N7T8][icon-default.png_t_N7T8]https://blog.csdn.net/zzzzzhxxx/article/details/136044643?spm=1001.2014.3001.5501][-CSDN_icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_zzzzzhxxx_article_details_136044643_spm_1001.2014.3001.5501][【LeetCode力扣】单调栈解决Next Greater Number（下一个更大值）问题-CSDN博客![icon-default.png?t=N7T8][icon-default.png_t_N7T8]https://blog.csdn.net/zzzzzhxxx/article/details/136030138?spm=1001.2014.3001.5501][LeetCode_Next Greater Number_-CSDN_icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_zzzzzhxxx_article_details_136030138_spm_1001.2014.3001.5501]

**如果觉得作者写的不错，求给博主一个大大的点赞支持一下，你们的支持是我更新的最大动力！**

[9696376d33b44045866ace87d897a1cd.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/f128f6c5cd5f43eba53610722be09961.gif
[e3b4a9a704e64c4f9a6e032f3342bb98.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/5078078b54d148498302697f38348fa5.png
[e3e0799a3dcd4d98b1a8029a1d5667ac.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/a4002842b48448c18379f556c79fdf2d.png
[61ff7d2b0aed4e439b0991a166446a3b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/5f520378398c44439f9f96ec649bb2c3.png
[9beb7bb0cf994c4b92ea5484f67d5e9e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/ab1a161767ef4f28835780a440a0979b.png
[dee5871aa3c7418b9ba59f7a73db3cf8.gif]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/08/54203dcc121549f0b1e86ef7fe0afd06.gif
[icon-default.png_t_N7T8]: https://csdnimg.cn/release/blog_editor_html/release2.3.6/ckeditor/plugins/CsdnLink/icons/icon-default.png?t=N7T8
[-CSDN_icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_zzzzzhxxx_article_details_136115808_spm_1001.2014.3001.5501]: https://blog.csdn.net/zzzzzhxxx/article/details/136115808?spm=1001.2014.3001.5501
[-CSDN_icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_zzzzzhxxx_article_details_136044643_spm_1001.2014.3001.5501]: https://blog.csdn.net/zzzzzhxxx/article/details/136044643?spm=1001.2014.3001.5501
[LeetCode_Next Greater Number_-CSDN_icon-default.png_t_N7T8_icon-default.png_t_N7T8_https_blog.csdn.net_zzzzzhxxx_article_details_136030138_spm_1001.2014.3001.5501]: https://blog.csdn.net/zzzzzhxxx/article/details/136030138?spm=1001.2014.3001.5501