Thread 类基本用法详解

迷南。 2024-03-16 11:48 49阅读 0赞

#### Thread 类基本用法详解 ####

*  Thread类的作用
 *  线程创建
 *   *  继承 Thread, 重写 run
     *  实现 Runnable, 重写 run
     *  继承 Thread, 重写 run, 使用匿名内部类
     *  实现 Runnable, 重写 run, 使用匿名内部类
     *  使用 lambda 表达式(==最推荐==)
 *  线程中断
 *   *  1.使用标志位来控制线程是否要停止
     *  2.使用Thread自带的标志位来控制线程是否要停止
 *  线程等待

## Thread类的作用 ##

> **Thread**是Java操作多线程**最核心**的类。

## 线程创建 ##

**Java中创建线程的方法有很多种！！！**

### 继承 Thread, 重写 run ###

//继承Thread类并重写run方法创建一个线程
    class Thread01 extends Thread{
        
        @Override
        public void run() {
        
            System.out.println("hello,thread");
        }
    }
    public class ThreadDemo {
        
        public static void main(String[] args) {
        
            //实例化一个线程对象
            Thread01 t=new Thread01();
            //真正去申请系统线程，参与CPU调度
            t.start();
        }
    }

### 实现 Runnable, 重写 run ###

//通过继承Runnable接口并实现run方法
    class MyRunnable implements Runnable{
        
        @Override
        public void run() {
        
            System.out.println("hello,thread");
        }
    }
    public class ThreadDemo {
        
        public static void main(String[] args) {
        
             //实例化Runnable对象
            MyRunnable runnable=new MyRunnable();
            //实例化线程对象并绑定任务
            Thread t=new Thread(runnable);
            t.start();
        }
    }

### 继承 Thread, 重写 run, 使用匿名内部类 ###

//通过Thread匿名内部类的方法创建一个线程
    public static void main(String[] args) {
        
           Thread t=new Thread(){
        
                //指定线程任务
                @Override
                public void run() {
        
                    System.out.println(Thread.currentThread().getName());
                }
            };
            t.start();
    }

### 实现 Runnable, 重写 run, 使用匿名内部类 ###

//通过Runnable匿名内部类创建一个线程
       public static void main(String[] args) {
        
          Thread t=new Thread(new Runnable() {
        
              //指定线程的任务
              @Override
              public void run() {
        
                  System.out.println(Thread.currentThread().getName());
              }
          });
          t.start();
       }

### 使用 lambda 表达式(最推荐) ###

//通过Lambda表达式的方式创建一个线程
    public static void main(String[] args) {
        
        Thread t=new Thread(()->{
        
            System.out.println("Hi");
        });
        t.start();
    }

**上述方法，只是语法规则不同，本质上是一样的方式，创造出的线程并无不同。**

> 面试题一：请说明Thread类中run和start的区别  
> 答案：  
> **作用功能不同：**  
> a.run方法的作用是描述线程具体要执行的任务；  
> b.start方法的作用是真正在操作系统内核里创建线程，并让新线程调用run方法。  
> **运行结果不同：**  
> a.run方法是一个类中的普通方法，主动调用和调用普通方法一样，会顺序执行一次。  
> b.start调用方法后，start方法内部会调用Java本地方法（封装了对系统底层的调用）真正的启动线程，并执行run方法中的代码，run方法执行完成后，线程进入销毁阶段。

## 线程中断 ##

> 中断的意思不是指让线程立即就停止，而是**通知线程应该要停止**，是否真的停止，**取决于**线程这里具体的代码写法。

### 1.使用标志位来控制线程是否要停止 ###

public static boolean flag=true;
        public static void main(String[] args) throws InterruptedException {
        
    
            Thread t=new Thread(()->{
        
                while (flag){
        
                    System.out.println("hello Thread");
                    try {
        
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
            });
            t.start();
            Thread.sleep(3000);
            //在主线程里就可以随时通过flag变量的取值，来操作t线程是否结束
            flag=false;
    
        }

>  *  自定义变量这种方式不能及时响应，尤其是在sleep休眠的时间比较久的时候。
>  *  这个代码之所以能够起到修改flag, t线程就结束，完全取决于 t 线程内部的代码。
>  *  代码里通过flag控制循环。因此这里只是告诉让这个线程结束，这个线程是否要结束，啥时候结束，都取决于 t 线程内部代码。

### 2.使用Thread自带的标志位来控制线程是否要停止 ###

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);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
        });
        t.start();
        Thread.sleep(3000);
        t.interrupt();
    }

> Thread.currentThread():这是Thread类的静态方法，通过这个方法可以获取到当前线程,哪个线程调用这个方法，就得到哪个线程的对象引用，类似于this。  
> isInterrupted()：判断线程是否终止，为true表示被终止，为false表示未被终止。  
> t.interrupt() ：在上述代码中，主线程调用t.interrupt()，相当于主线程通知 t 线程要终止。

![在这里插入图片描述][fa28d85a5f9e461bb43bc38534882767.png_pic_center]

> 此处interrupt会做两件事：  
> 1.把线程内部的标志位（boolean）给设置成true。  
> 2.如果线程在进行sleep，就会触发异常，把sleep唤醒。  
> 注意：  
> 在唤醒sleep的时候，会把刚才设置的这个标志位，再设置回false。(清空了标志位)  
> 这就导致上述代码在sleep的异常被catch完了之后，循环还要继续执行！！  
> **上述代码执行结果：**  
> ![在这里插入图片描述][df579cd5c28d44998bf16f05ad150d3f.png_pic_center]  
> 问题一:为啥sleep要清除标志位？  
> 唤醒sleep之后,线程到底是否要终止，到底是立即终止还是稍后终止，取决于线程内部代码。

## 线程等待 ##

> 线程等待是指一个线程在执行过程中暂停自己的运行，并等待其他线程完成一定的操作后再继续执行。**简单来说，就是控制多个线程的执行顺序。**  
> 线程等待的实现方式有很多种，其中最常见的方式是使用线程的join()方法。**当一个线程调用另一个线程的join()方法时，它会被阻塞，直到被调用的线程执行完毕并退出。**

![在这里插入图片描述][80ac231bd8884a76af22961ffd51b827.png_pic_center]  
**上述代码执行结果：**  
![在这里插入图片描述][fc6529d903f84428ad074988ef3a702f.png_pic_center]

[fa28d85a5f9e461bb43bc38534882767.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/f73a7af8054b4740810ee82ef443685a.png
[df579cd5c28d44998bf16f05ad150d3f.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/2eaf7e18d9334b85b5cbe6942ee9a548.png
[80ac231bd8884a76af22961ffd51b827.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/02afbf32579447bea55ca9c8e0b419e7.png
[fc6529d903f84428ad074988ef3a702f.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/16/527c39ca46834acc982d7a158539f458.png