Thread 类基本用法详解

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 线程要终止。

此处interrupt会做两件事：
1.把线程内部的标志位（boolean）给设置成true。
2.如果线程在进行sleep，就会触发异常，把sleep唤醒。
注意：
在唤醒sleep的时候，会把刚才设置的这个标志位，再设置回false。(清空了标志位)
这就导致上述代码在sleep的异常被catch完了之后，循环还要继续执行！！
上述代码执行结果：

问题一:为啥sleep要清除标志位？
唤醒sleep之后,线程到底是否要终止，到底是立即终止还是稍后终止，取决于线程内部代码。

线程等待

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

上述代码执行结果：

来源地址：https://blog.csdn.net/m0_63904107/article/details/130982938