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

不念不忘少年蓝@ 2024-02-22 06:29 26阅读 0赞

#### 文章目录 ####

*  线程创建
 *  线程中断
 *  线程等待
 *  线程休眠

## 线程创建 ##

方法一：用一个类 继承Thread 重写run方法

//创建一个类 继承Thread
    class MyThread extends Thread {
        
        //run方法是线程的入口
        @Override
        public void run() {
        
            while (true){
        
                System.out.println("hello Thread");
                try {
        
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
        }
    }

这样一个线程就创建好了，然后可以创建MyThread实例。

public class demo1 {
        
        public static void main(String[] args) throws InterruptedException {
        
            Thread thread = new MyThread();//向上转型 也可以写成MyThread myThread = new MyThread();
            //运行线程
            thread.start();
            while (true){
        
                System.out.println("hello main");
                //每1000毫秒打印一次 也就是休眠一秒
                Thread.sleep(1000);
            }
        }
    }

方法二：实现 Runnable 接口 重写run方法

class MyRunnable implements Runnable {
        
        @Override
        public void run() {
        
            while (true){
        
                System.out.println("hello Runnable");
                try {
        
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
        }
    }

我们可以通过实现Runnable接口来实现创建线程

public class demo2 {
        
        public static void main(String[] args) throws InterruptedException {
        
            //runnable表示的是一个可运行的任务 这个任务是交给线程来负责执行的
            Runnable runnable = new MyRunnable();
            Thread t = new Thread(runnable);
            t.start();
            while (true){
        
                System.out.println("jello main");
                Thread.sleep(1000);
            }
        }
    }

方法三：使用匿名内部类，继承Thread 重写run方法

public class demo3 {
        
        public static void main(String[] args) throws InterruptedException {
        
            //使用匿名类创建 Thread 子类对象
            Thread t = new Thread(){
        
                @Override
                public void run() {
        
                    while (true){
        
                        System.out.println("thread");
                        try {
        
                            Thread.sleep(1000);
                        } catch (InterruptedException e) {
        
                            throw new RuntimeException(e);
                        }
                    }
                }
            };
            t.start();
            while (true){
        
                System.out.println("main");
                Thread.sleep(1000);
            }
        }
    }

方法四：使用匿名内部类，实现Runnable 重写run方法

public class demo4 {
        
        public static void main(String[] args) {
        
            //使用匿名内部类创建 Runnable 子类对象
            Thread t = new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    while (true){
        
                        System.out.println("thread");
                    }
                }
            });
            t.start();
            while (true){
        
                System.out.println("main");
            }
        }
    }

方法五：使用 lambda 表达式创建 Runnable 子类对象

public class demo5 {
        
        public static void main(String[] args) {
        
            //lambda 表达式创建 Runnable 子类对象  
            //lambda 表达式本质上是一个匿名函数
            Thread t = new Thread(()->{
        
               while (true){
        
                   System.out.println("thread");
               }
            });
            t.setDaemon(true);
            t.start();
    
        }
    }

Thread 类是 JVM 用来管理线程的一个类，换句话说，每个线程都有**一个唯一**的 Thread 对象与之关联。

创建好线程之后我们可以运行程序观察线程，多线程运行的时候我们可以使用jdk的bin目录下的 jconsole.exe 来观察该进程里多线程的情况。如果运行 jconsole.exe 什么都不显示，就需要以管理员的方式运行。

![在这里插入图片描述][7ff8b4d27e2744abb5d29a7dc0bf82ad.png]

![在这里插入图片描述][9b7718dede4d410ab9864790ada78ab3.png]  
![在这里插入图片描述][49bfa77257d4451faae171a6680f308e.png]

**Thread类的常见构造方法**

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">Thread()</td> 
   <td align="left">创建线程对象</td> 
  </tr> 
  <tr> 
   <td align="left">Thread(Runnable target)</td> 
   <td align="left">使用 Runnable 对象创建线程对象</td> 
  </tr> 
  <tr> 
   <td align="left">Thread(String name)</td> 
   <td align="left">创建线程对象，并命名</td> 
  </tr> 
  <tr> 
   <td align="left">Thread(Runnable target, String name)</td> 
   <td align="left">使用 Runnable 对象创建线程对象，并命名</td> 
  </tr> 
 </tbody> 
</table>

\*\*Thread 的几个常见属性 \*\*

<table> 
 <thead> 
  <tr> 
   <th align="center">属性</th> 
   <th align="center">获取方法</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">ID</td> 
   <td align="center">getId()</td> 
  </tr> 
  <tr> 
   <td align="center">名称</td> 
   <td align="center">getName()</td> 
  </tr> 
  <tr> 
   <td align="center">状态</td> 
   <td align="center">getState()</td> 
  </tr> 
  <tr> 
   <td align="center">优先级</td> 
   <td align="center">getPriority()</td> 
  </tr> 
  <tr> 
   <td align="center">是否为后台线程</td> 
   <td align="center">isDaemon()</td> 
  </tr> 
  <tr> 
   <td align="center">是否存活</td> 
   <td align="center">isAlive()</td> 
  </tr> 
  <tr> 
   <td align="center">是否被中断</td> 
   <td align="center">isInterrupted()</td> 
  </tr> 
 </tbody> 
</table>

*  ID 是线程的唯一标识，不同线程不会重复
 *  状态就是表示线程当前所处的一个情况
 *  优先级高的线程理论上来说更容易被调度到
 *  关于**后台线程**也可以叫**守护线程**，后台线程不结束也不会影响整个线程的结束，但是如果一个前台线程没有执行结束，那么整个进程也一定不会结束（JVM会在一个进程的所有非后台线程结束后，才会结束运行）
 *  是否存活，就是 run 方法是否运行结束

## 线程中断 ##

在Java里面中断/销毁一个线程其实就是让run尽快执行结束，我们可以在代码中手动创建标志位来作为run的结束条件。

public class demo6 {
        
        private static boolean isQuit = false;//设置标志位
        public static void main(String[] args) throws InterruptedException {
        
            Thread t = new Thread(()->{
        
                System.out.println("线程正在工作");
                while (!isQuit){
        
                    System.out.println("thread");
                    try {
        
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
                System.out.println("线程工作结束");
            });
            t.start();
            Thread.sleep(5000);
            isQuit=true;
            System.out.println("hello");
        }
    }

运行结果

![在这里插入图片描述][d44590aec0bc48fda09e40751355157a.png]

上述方法手动创建标志位，当线程内部sleep的时候，，主线程修改变量，新线程不能及时响应，我们就可以使用Thread.currentThread().isInterrupted() 来代替自定义标志位。Thread 内部包含了一个 boolean 类型的变量作为线程是否被中断的标记 。

<table> 
 <thead> 
  <tr> 
   <th align="left">方法</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="left">public void interrupt()</td> 
   <td align="left">中断对象关联的线程，如果线程正在阻塞，则以异常方式通知， 否则设置标志位</td> 
  </tr> 
  <tr> 
   <td align="left">public static boolean interrupted()</td> 
   <td align="left">判断当前线程的中断标志位是否设置，调用后清除标志位</td> 
  </tr> 
  <tr> 
   <td align="left">public boolean isInterrupted()</td> 
   <td align="left">判断对象关联的线程的标志位是否设置，调用后不清除标志位</td> 
  </tr> 
 </tbody> 
</table>

public class demo7 {
        
        public static void main(String[] args) throws InterruptedException {
        
            Thread t = new Thread(()->{
        
                //Thread类内部 有一个标志位 可以用来判断当前的循环是否要结束
                //Thread.currentThread()就是获取当前线程
               while (!Thread.currentThread().isInterrupted()){
        
                   System.out.println("线程正在工作");
                   try {
        
                       Thread.sleep(1000);
                   } catch (InterruptedException e) {
        
                       e.printStackTrace();
                       //break; //加了break后会立即中断
                       //我们可以加一些其他的代码 然后再break 这样我们可以有更多的操作空间 
                   }
               }
            });
            t.start();
            Thread.sleep(5000);
            System.out.println("通过标志位使t线程终止");
            //interrupt可以使sleep内部出现一个异常 从而使线程被提前唤醒 手动创建出的标志位无法达到这个效果
            t.interrupt();//把上述标志位设置为true 即使线程内部出现阻塞 也可以被唤醒 
        }
    }

我们观察上面代码的运行结果

![在这里插入图片描述][dd0e9d6a41144f7991c1063ea9b6dac5.png]

虽然异常出现了，sleep被唤醒但是循环没有终止，t 线程任然在继续工作，并没有停止。Java这样设定是因为，当java收到要中断信息的时候，我们希望它可以自由决定接下来怎么处理。

## 线程等待 ##

等待一个线程我们使用 join()

public class demo8 {
        
        public static void main(String[] args) throws InterruptedException {
        
            Thread t = new Thread(() -> {
        
                for (int i = 0; i < 5; i++) {
        
                    System.out.println("线程开始工作");
                    try {
        
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
        
                        e.printStackTrace();
                    }
                }
    
            });
            t.start();
            System.out.println("线程开始等待");
            t.join();//主线程等待 t 线程结束 谁调用join谁是被等的
            System.out.println("等待结束");
        }
    }

![在这里插入图片描述][b1ecb2d4ea8447b282c2b941788ef3a0.png]

一旦调用 join 主线程就会发生阻塞，这样 t 线程就可以完成后面的工作，主线程要一直阻塞到 t 线程执行结束才会解除阻塞。

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th align="left">说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public void join()</td> 
   <td align="left">等待线程结束</td> 
  </tr> 
  <tr> 
   <td>public void join(long millis)</td> 
   <td align="left">等待线程结束，最多等 millis 毫秒</td> 
  </tr> 
  <tr> 
   <td>public void join(long millis, int nanos)</td> 
   <td align="left">等待线程结束，但可以更高精度 最多等 nanos 纳秒</td> 
  </tr> 
 </tbody> 
</table>

## 线程休眠 ##

<table> 
 <thead> 
  <tr> 
   <th>方法</th> 
   <th>说明</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>public static void sleep(long millis) throws InterruptedException</td> 
   <td>休眠当前线程 millis 毫秒</td> 
  </tr> 
  <tr> 
   <td>public static void sleep(long millis, int nanos) throws InterruptedException</td> 
   <td>休眠当前线程 nanos 纳秒</td> 
  </tr> 
 </tbody> 
</table>

public class demo11 {
        
        public static void main(String[] args) throws InterruptedException {
        
            System.out.println(System.currentTimeMillis());
            Thread.sleep(3 * 1000);//休眠三秒
            System.out.println(System.currentTimeMillis());
        }
    }

[7ff8b4d27e2744abb5d29a7dc0bf82ad.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/d6e717f58fe146188b5141cab7e5cf20.png
[9b7718dede4d410ab9864790ada78ab3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/6b2570de42ad44bfa281ac725f5711e3.png
[49bfa77257d4451faae171a6680f308e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/0216a693969f4a16ba43793f2eef1ec9.png
[d44590aec0bc48fda09e40751355157a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/c5679dc7c72d4b7094bdffb729670cc0.png
[dd0e9d6a41144f7991c1063ea9b6dac5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/cdd2e60b843e42da91db8b68277ee0ff.png
[b1ecb2d4ea8447b282c2b941788ef3a0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/22/aac342211de64f2a867decb467fd38fd.png