一篇文章掌握Java Thread的类及其常见方法

更新时间：2022年03月02日 14:56:01 作者：/少司命

Thread类用于操作线程，是所以涉及到线程操作(如并发)的基础。本文将通过代码对Thread类的功能作用及其常见方法进行分析

一，Thread 的几个常见属性

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

Java中创建线程

显示继承Thread，重写run方法来指定线程执行的代码

匿名内部类来继承Thread，重写run方法来指定线程执行的代码

显示实现Runnable接口，重写run方法

匿名内部类来继承Runnable接口，重写run方法

通过lambda表达式来描述执行的代码

属性	获取方法
ID	getId()
名称	getNmame()
状态	getState()
优先级	getPriority()
是否后台线程	isDaemon()
是否存活	isAlive()
是否被中断	isInterrupted()

ID 是线程的唯一标识，不同线程不会重复

名称是各种调试工具用到状态表示线程当前所处的一个情况，下面我们会进一步说明

优先级高的线程理论上来说更容易被调度到

关于后台线程，需要记住一点：JVM会在一个进程的所有非后台线程结束后，才会结束运行。

是否存活，即简单的理解，为 run 方法是否运行结束了

线程的中断问题，下面我们进一步说明

public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread("123"){
            @Override
            public void run() {
                for (int i = 0; i < 10; i++){
                    System.out.println(Thread.currentThread().getName());
                    try{
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("线程退出");
            }
        };
 
        //这一组属性，线程创建完成后，属性就不变了
        System.out.println(t.getName());
        System.out.println(t.getPriority());
        System.out.println(t.isDaemon());
        System.out.println(t.getId());
        //这组属性会随着线程的运行而开始改变
        System.out.println(t.isAlive());
        System.out.println(t.isInterrupted());
        System.out.println(t.getState());
 
        t.start();
 
        while (t.isAlive()){
            System.out.println("123 正在运行");
            System.out.println(t.getState());
            System.out.println(t.isInterrupted());
            Thread.sleep(300);
        }
    }

二，线程调试

1，启动一个线程

之前我们已经看到了如何通过覆写 run 方法创建一个线程对象，但线程对象被创建出来并不意味着线程就开始运行了。

覆写 run 方法是提供给线程要做的事情的指令清单

线程对象可以认为是把李四、王五叫过来了

而调用 start() 方法，就是喊一声：”行动起来！“，线程才真正独立去执行了。

 static class MyThread extends Thread{
        @Override
        public void run() {
            System.out.println("我是一个线程");
        }
    }
 
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
    }

2，中断一个线程

中断让一个程序结束，结束可能有两种情况

1，已经把任务执行完了

2，任务执行到一半，被强制结束

public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(){
            @Override
            public void run() {
               while (! isQuit){
                   System.out.println("正在转账");
                   try {
                       Thread.sleep(500);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
                System.out.println("转账终止");
            }
        };
        t.start();
        Thread.sleep(500);
        System.out.println("有内鬼，终止交易");
        isQuit = true;
    
}

public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(){
            @Override
            public void run() {
                while (!Thread.interrupted()){
                    System.out.println("正在转账");
                    try {
                        Thread.sleep(5000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        break;
                    }
                }
                System.out.println("转账终止");
            }
        };
        t.start();
        Thread.sleep(5000);
        System.out.println("有内鬼，终止交易");
        t.interrupt();
    }

thread 收到通知的方式有两种：

1. 如果线程因为调用 wait/join/sleep 等方法而阻塞挂起，则以 InterruptedException 异常的形式通知，清除中断标志

当出现 InterruptedException 的时候, 要不要结束线程取决于 catch 中代码的写法. 可以选择忽略这个异常, 也可以跳出循环结束线程.

2.否则，只是内部的一个中断标志被设置，thread 可以通过

Thread.interrupted() 判断当前线程的中断标志被设置，清除中断标志

Thread.currentThread().isInterrupted() 判断指定线程的中断标志被设置，不清除中断标志

这种方式通知收到的更及时，即使线程正在 sleep 也可以马上收到。

public static void main(String[] args) {
        Thread t = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 10; i++){
                    System.out.println(Thread.interrupted());
                }
            }
        };
        t.start();
        t.interrupt();
    }

public static void main(String[] args) {
        Thread t = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 10; i++){
                    System.out.println(Thread.currentThread().isInterrupted());
                }
            }
        };
        t.start();
        t.interrupt();
    }

3，等待一个线程

t1与t2串行执行

 public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 10; i++){
                    System.out.println("我是线程1");
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
 
 
        Thread t2 = new Thread(){
            @Override
            public void run() {
               for (int i = 0; i < 10; i++){
                   System.out.println("我是线程2");
                   try {
                       Thread.sleep(50);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
            }
        };
 
 
        t1.start();
        t1.join();
        t2.start();
        t2.join();
        System.out.println("主线程执行完毕");
    }

t1与t2并发执行

public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(){
            @Override
            public void run() {
                for (int i = 0; i < 10; i++){
                    System.out.println("我是线程1");
                    try {
                        Thread.sleep(50);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
 
 
        Thread t2 = new Thread(){
            @Override
            public void run() {
               for (int i = 0; i < 10; i++){
                   System.out.println("我是线程2");
                   try {
                       Thread.sleep(50);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
            }
        };
 
 
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("主线程执行完毕");
    }

4，休眠线程

public static void main(String[] args) throws InterruptedException {
        System.out.println(System.currentTimeMillis());
        Thread.sleep(1000);
        System.out.println(System.currentTimeMillis());
    }

1，如果线程在正常运行计算判断逻辑，此时就是在就绪队列中排队，调度器就会从就绪队列中筛选出合适的PCB让他在CPU上运行

2，如果某个线程调用sleep就会让对应的线程的PCB进入阻塞队列，阻塞队列无法在PCB上运行

3，时间到了之后，就自动把这个PCB拿回到原来的就绪队列中

到此这篇关于一篇文章掌握Java Thread的类及其常见方法的文章就介绍到这了,更多相关Java Thread内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

您可能感兴趣的文章:

Java TimeoutException：服务调用超时异常的正确解决方案
在现代软件开发中,服务间通信是构建分布式系统的基础,然而,网络延迟、服务负载、资源竞争等因素都可能导致服务调用超时,TimeoutException是Java中表示服务调用超时的常见异常之一,本文将探讨TimeoutException的成因及解决方案,需要的朋友可以参考下
2024-12-12
SpringBoot如何获取Kafka的Topic列表
这篇文章主要介绍了SpringBoot如何获取Kafka的Topic列表问题，具有很好的参考价值，希望对大家有所帮助。如有错误或未考虑完全的地方，望不吝赐教
2022-09-09
java参数传值代码举例
在编程中往方法中传递参数的方法往往有两种,一种是值传递,一种是引用传递,而在java中所有的参数传递全部都是值传递,这篇文章主要给大家介绍了关于java参数传值的相关资料,需要的朋友可以参考下
2024-03-03
详解eclipse中Maven工程使用Tomcat7以上插件的方法
本篇文章主要介绍了详解eclipse中Maven工程使用Tomcat7以上插件的方法，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
2017-12-12
JAVA中@ApiModel和@ApiModelProperty注解实战代码
这篇文章主要给大家介绍了关于JAVA中@ApiModel和@ApiModelProperty注解的相关资料,@ApiModel注解是用在接口相关的实体类上的注解,它主要是用来对使用该注解的接口相关的实体类添加额外的描述信息,常常和@ApiModelProperty注解配合使用,需要的朋友可以参考下
2024-03-03
elasticsearch启动警告无法锁定JVM内存
今天小编就为大家分享一篇关于elasticsearch启动警告无法锁定JVM内存，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
2019-03-03
Spring Boot 条件注解详情
这篇文章主要介绍了Spring Boot 条件注解详情，SpringBoot条件注解@Conditional，可用于根据某个特定的条件来判断是否需要创建某个特定的Bean，下文更多相关介绍，需要的小伙伴可以参考一下
2022-05-05
Java纯代码实现导出pdf合并单元格
这篇文章主要为大家详细介绍了Java如何纯代码实现导出pdf与合并单元格功能,文中的示例代码讲解详细,感兴趣的小伙伴可以跟随小编一起学习一下
2023-12-12
使用IDEA创建Servlet程序的详细步骤
在学习servlet过程中,参考的教程是用eclipse完成的,而我在练习的过程中是使用IDEA的,在创建servlet程序时遇到了挺多困难,在此记录一下如何用IDEA完整创建一个servlet程序,感兴趣的朋友一起看看吧
2024-08-08
Java如何分析算法的时间和空间复杂度
这篇文章主要介绍了Java如何分析算法的时间和空间复杂度，在计算机科学中，计算复杂性解释了算法的性能。文章围绕主题展开详细的内容介绍，具有一定的参考价值，需要的朋友可以参考一下
2022-06-06