多线程Thread（初阶二：Thread类及常⻅⽅法）

目录

一、Thread 的常⻅构造⽅法

继承Thread代码：

实现Runnable接口代码:

二、Thread 的⼏个常⻅属性

1、id：

2、获取线程的名字。

3、进程的状态：

4、在java中设置的优先级，

5、是否后台线程，

6、是否存活，

7、是否中断，

8、等待线程（结束），

9、获取线程的引用，currentThread()

一、Thread 的常⻅构造⽅法

最后一个线程组的概念是java的概念，和系统中的线程组不一样，不是同一个东西。

第一个和第二个构造方法在初阶一有介绍，

链接：多线程Thread（初阶一：认识线程）-CSDN博客

第三是创建一个线程，并且可以给这个线程命名，并不是它默认的Thread-0 / 1 / 2.....，第四个也是可以给线程对象命名，不过是使用接口的方法。

继承Thread代码：

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("hello thread1");
    }
    String name;
    public MyThread(String name) {
        super(name);
        this.name = name;
    }
}
public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t1 = new MyThread("这是我的线程");
        t1.start();
        Thread t2 = new Thread("这是我的线程"){
            @Override
            public void run() {
                System.out.println("hello thread2");
            }
        };
        t2.start();
    }
}

执行效果：

两个线程：

上面两种的两种创建线程方式都可以。

实现Runnable接口代码:

class MyThread2 extends Thread {
    String name;
    public MyThread2(String name) {
        super(name);
        this.name = name;
    }
    @Override
    public void run() {
        System.out.println("hello thread1");
    }
}
public class TestDemo2 {
    public static void main(String[] args) {
        Thread t1 = new MyThread2("这是我的线程1");
        t1.start();
        Thread t2 = new Thread("这是我的进程2") {
            @Override
            public void run() {
                System.out.println("hello thread2");
            }
        };
        t2.start();
    }
}

执行效果：

两个线程：

注意：我们创建的线程如果不起名字，默认是Thread-0 1 2 3....，给不同线程起不同名字，对于线程的执行，没啥影响，主要是为了方便调试；线程之间的名字是可以重复的，在同一个工作中，需要多个线程完成，都可以起一样的名字；但是名字也不要乱起，最后要有一定的描述性。

二、Thread 的⼏个常⻅属性

1、id：

jvm自动分配的身份标识，会保证唯一性。

2、获取线程的名字。

3、进程的状态：

就绪状态、阻塞状态；线程也有状态，Java中对线程的状态进行了进一步的区分（比系统原生的状态更丰富一些）。

4、在java中设置的优先级，

效果不是很明显，因为系统是随机调度的（对内核的调度器调度过程会产生一些影响）。

5、是否后台线程，

也称为是否守护线程（比较抽象），所以记住和理解是否后台线程会轻松一些，与此相反，也有前台线程（和Android上的前台app，后台app完全不同）。

后台线程和前台线程的区别：前台线程的运行，会阻止进程结束

                                               后台线程的运行，不会阻止进程结束

我们创建的线程，默认是前台进程。

如下代码：

public class TestDemo3 {
    public static void main(String[] args) {
        Thread t = new Thread() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        };
        t.start();
    }
}

执行效果：会不停的输出打印hello thread

那我们试着把这个线程设置为后台线程试试（默认为前台），代码：

public class TestDemo3 {
    public static void main(String[] args) {
        Thread t = new Thread() {
            @Override
            public void run() {
                while (true) {
                    System.out.println("hello thread");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        };
        //在start之前，设置线程为后台线程（不能在start之后设置）
        t.setDaemon(true);
        t.start();
    }
}

执行效果：

根本就没有打印hello thread，进程就结束了，因为是后台进程，不会阻止进程的结束。

设为true是后台，后台，可以理解为背后，不出面的人，你感知不到；后台不会阻止进程结束。

不设为true是前台，前台，可以理解为明面上的人，你能感知到；前台会阻止进程结束。

6、是否存活，

isAlive( )表示内核中的线程（PCB）是否还存在。java代码中定义的线程对象（Thread）实现，虽然是表示一个线程，但这个对象本身的生命周期，和内核中的PCB生命周期  ，是不完全一样的。

isAlive的测试，代码：

public class TestDemo4 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        System.out.println("start之前：" + t.isAlive());
        t.start();
        System.out.println("start之后" + t.isAlive());
        Thread.sleep(2000);
        System.out.println("t结束之后" + t.isAlive());
    }
}

执行效果：

解释：启动线程之前，也就是start之前，t这个实例线程是还没开始的，所以isAlive返回的是false，start后就查看这个线程存不存在，因为线程也刚启动，所以isAlive返回的是true，休眠两秒之后，t线程已经跑完了，所以isAlive返回的也是false。

7、是否中断，

也是终止的意思。

下面写一个代码，用boolean类型的变量来控制while循环，也起到终止线程的作用。

public class ThreadDemo1 {
    private static boolean isQuit = false;
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (!isQuit) {
                System.out.println("我是一个线程，正在工作");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println("线程工作完毕");
        });
        t.start();
        Thread.sleep(3000);

        System.out.println("让线程结束");
        isQuit = true;
    }
}

注意：这里的isQuit变量放在类中，不放在方法里作为局部变量的原因是涉及到了变量捕获，如果放在main方法里，是局部变量，就必须要加 final 修饰将其变成常量，为什么呢？这时因为main线程和我们创建的线程的栈帧生命周期不同，如果main线程先结束了，我们创建的线程要获取这个变量，但是我们main线程的栈帧生命周期已经结束了，我们拿不到这个变量，java这里的做法就比较暴力，直接把这个变量变成常量，要么这个变量就是全局变量，以至于不会发生上面的情况。

执行效果：

这时，我们也可以使用jdk里自带的方法：isInterrupted( )

代码如下：

public class ThreadDemo2 {
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("我是一个线程，正在工作");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("线程执行完毕");
        });

        t.start();

        Thread.sleep(3000);
        System.out.println("让线程结束");
        t.interrupt();
    }
}

执行效果：

这个线程并不会结束，会继续执行。

解释：可以看到这里抛出了个异常，而这个异常是InterruptedException 异常

如果没有sleep，interrupt是可以让线程顺利结束的，但是有了sleep就会引起变数。

这说明，sleep这出现问题了，为什么呢？原因是这个线程还在执行，main线程休眠3秒后，终止了这个线程，但sleep还没休眠够1秒，这里就会提前唤醒。

这里，提前唤醒，会做两件事：

1、抛出 InterruptedException （紧接着就会被catch获取到）。

2、清除 Thread 对象的 isInterrupt 标志位。（sleep清空标志位，是为了给程序猿更多的“可操作性空间”）。

所以，interrupt已经把标志位设置为true了，sleep被提前唤醒，清除了isInterrupt标志位后，就又把标志位设回了false，这个while循环还是能进去的，所以线程还在继续执行。

此时，程序猿就可以在catch语句中加入一些代码，来做一些处理：

1、让线程立即结束。（加上break）

2、让线程不结束，继续执行。（不加break）

3、让线程执行一些逻辑后，再结束。（写一些其他代码，再加break）

对于一个服务器程序来说，稳定性很重要，这些所谓的“问题”，在java中就会以异常的形式体现出来，可以通过catch语句，对这些异常进行处理。主要的几种处理方式：

1、尝试自动恢复

2、记录日志

3、发出警报

8、等待线程（结束），

join（ ）。我们知道，多线程的执行顺序是不同的（随机调度，抢占式执行），有不可预期性，虽然线程的调度是无序的，但是我们可以调用一些api，来影响带线程的执行顺序，join就是一种方式，影响 线程结束 的先后顺序。比如：t2 线程等待 t1，这时，一定是 t1先结束，t2 后结束。这里的join就会使 t2 线程阻塞。

代码：

public class ThreadDemo3 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
           for (int i = 0; i < 5; i++) {
               System.out.println("我是一个线程，正在工作");
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
           }
            System.out.println("线程结束");
        });
        
        t.start();
        //t.join();
        
        System.out.println("这时一个主线程，在t线程结束后再执行");
    }
}

我们想让t线程执行完后再执行主线程，如果不写join方法。因为多线程的调度是随机性的，执行效果如下：

执行效果和我们预期的不一样，加上join方法后，

代码：

public class ThreadDemo3 {
    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) {
                   throw new RuntimeException(e);
               }
           }
            System.out.println("线程结束");
        });
        t.start();
        t.join();
        System.out.println("这时一个主线程，在t线程结束后再执行");
    }
}

执行效果：

结果和我们想要预期效果相同。这里的join的意思是：让 t 线程执行完，再执行本线程。

这里是让main线程主动放弃去调度器调度，t 线程执行完后，main线程才执行，这也代表哪个线程调用join，哪个线程就是阻塞等待。这里就有了先后顺序。

注意：这里的先后顺序和优先级不同，优先级是系统调度器，在内核中完成的工作，即使优先级有差异，但是每个线程的执行顺序还是随机的（控制不了）。

等待线程结束还有两个重载方法，里面放的是要等待的时间,如图：

如果join不加参数，就是死等，第一个加参数的就是：等待多少毫秒，第二个加参数：数值精确到纳秒，不过很少用，因为计算机精确不到这么小。加参数是带有时间的等。

注意，有时候不想等，我们也可以不等，例如加 interrupt，可以终止这个等待，我们也可以在idea看到join的实现，是throws了 InterruptedException的。

9、获取线程的引用，currentThread()

我们对于一个类继承Thread是可以通过this拿到线程的实例的，

代码如下：

class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("id:"+ this.getId() + " name:" + this.getName());
    }
}
public class ThreadDemo1 {
    public static void main(String[] args) {
        Thread t = new MyThread();
        t.start();
    }
}

效果如下：

但是，如果是接口或者我们使用匿名内部类 / lambda表达式，就不能获取到Thread的引用了，这时，Thread已经给我们提供了方法获取引用了：Thread.currentThread()。如下展示：

代码：

public class ThreadDemo2 {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            Thread t = Thread.currentThread();
            System.out.println(t.getId());
        });
        Thread t2 = new Thread(() -> {
            Thread t = Thread.currentThread();
            System.out.println(t.getName());
        });
        t1.start();
        t2.start();
    }
}

效果如下：

都看到这了，点个赞再走吧，谢谢谢谢谢！！！

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/184464.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

OpenAI惊天100小时，事件全记录

OpenAI惊天100小时，事件全记录

以下内容为结合这次OpenAI事件经过所做的梳理和总结&#xff0c;里面包含各种八卦和谣言&#xff0c;也是此次事件的狼人杀同人传记&#xff0c;借用了狼人杀游戏中的各种桥段&#xff0c;请各位看官酌情服用。 剧中人物&#xff1a; 好人阵营&#xff08;Sam&Greg&#xf…
阅读更多...
【深度学习】基于深度学习的超分辨率图像技术一览

【深度学习】基于深度学习的超分辨率图像技术一览

超分辨率(Super-Resolution)即通过硬件或软件的方法提高原有图像的分辨率&#xff0c;图像超分辨率是计算机视觉和图像处理领域一个非常重要的研究问题&#xff0c;在医疗图像分析、生物特征识别、视频监控与安全等实际场景中有着广泛的应用。 SR取得了显著进步。一般可以将现有…
阅读更多...
在自己的项目中调用别人的库的方法（static lib库，dynamic lib库以及dll动态库）

在自己的项目中调用别人的库的方法（static lib库，dynamic lib库以及dll动态库）

众所周知&#xff0c;出现.lib, .dll这种文件的原因是为了保护源代码&#xff0c;这个就不细说了。 用OpenCV的开源库来举个例子看一下就知道了&#xff1a; bin文件夹里面放的都是dll文件&#xff1b; lib文件夹里面放的都是伴随dll文件的动态lib文件&#xff1b; staticli…
阅读更多...
20231124给RK3399的挖掘机开发板在Andorid10下加鼠标右键返回

20231124给RK3399的挖掘机开发板在Andorid10下加鼠标右键返回

20231124给RK3399的挖掘机开发板在Andorid10下加鼠标右键返回 2023/11/24 12:19 百度&#xff1a;RK3399 Android10 右键返回 https://blog.csdn.net/danhu/article/details/122467256 android9/android10 鼠标右键返回(已验证) danhu 于 2022-01-13 09:46:42 发布 android10 …
阅读更多...
Django JSONField/HStoreField SQL注入漏洞（CVE-2019-14234）

Django JSONField/HStoreField SQL注入漏洞（CVE-2019-14234）

漏洞描述 Django 于2019年8月1日 日发布了安全更新&#xff0c;修复了 JSONField 和 HStoreField 两个模型字段的 SQL 注入漏洞。 参考链接&#xff1a; Django security releases issued: 2.2.4, 2.1.11 and 1.11.23 | Weblog | DjangoDjango JSONField SQL注入漏洞&#x…
阅读更多...
【Git】一文教你学会 submodule 的增、查、改、删

【Git】一文教你学会 submodule 的增、查、改、删

添加子模块 $ git submodule add <url> <path>url 为想要添加的子模块路径path 为子模块存放的本地路径 示例&#xff0c;添加 r-tinymaix 为子模块到主仓库 ./sdk/packages/online-packages/r-tinymaix 路径下&#xff0c;命令如下所示&#xff1a; $ git subm…
阅读更多...
让工作效率提升10倍：十大AIGC工具评测【建议收藏】

让工作效率提升10倍：十大AIGC工具评测【建议收藏】

AI技术的普及已经在近年来不断增长。这种技术已经改变了我们与电脑的互动方式&#xff0c;让我们能够更高效、更自然地完成任务。本文将展示10个基于ChatGPT、GPT-3.5和 GPT-4.0 AI模型构建的最强大的资源&#xff0c;使您更容易充分利用它们的潜力。因此&#xff0c;如果您想利…
阅读更多...
C语言--不创建第三个变量，实现对两个数字的交换

C语言--不创建第三个变量，实现对两个数字的交换

我们先来看一下&#xff0c;创建第三个变量交换两个数字。 #include<stdio.h> {int a2;int b3;int tmp0;tmpa;ab;btmp;return 0; } 再看一下不创建的方法 法一&#xff1a; //加减法 缺点可能会溢出 int main() {int a3;int b5;printf("before:a%d b%d\n"…
阅读更多...
Sublime Text 4168最新代码编辑

Sublime Text 4168最新代码编辑

Sublime Text是一款功能强大的文本编辑器&#xff0c;具有以下主要功能&#xff1a; 支持多种编程语言的语法高亮和代码自动完成功能&#xff0c;包括Python、JavaScript、HTML、CSS等。提供代码片段&#xff08;Snippet&#xff09;功能&#xff0c;可以将常用的代码片段保存…
阅读更多...
C++发展历史：从C++98到C++26

C++发展历史：从C++98到C++26

有趣的图片 C标准遵循3年开发周期&#xff0c;并以发布年份命名。C在临发布的一年前会进入“功能冻结期&#xff08;feature freeze&#xff09;”&#xff0c;即版本开发进入半稳定状态&#xff0c;不再添加重大功能及特性&#xff0c;着重于修复各种BUG。因此&#xff0c;直到…
阅读更多...
HandBrake 1.7 近日发布

HandBrake 1.7 近日发布

导读HandBrake 1.7 近日发布&#xff0c;作为这个开源、免费和跨平台视频转码器应用程序的重大更新&#xff0c;适用于 GNU/Linux、macOS 和 Windows 系统。 在 HandBrake 1.6 发布近一年后&#xff0c;HandBrake 1.7 版本为 Linux 用户提供了许多好处&#xff0c;包括视频摘要…
阅读更多...
百度文心一言（千帆大模型）聊天API使用指导

百度文心一言（千帆大模型）聊天API使用指导

开篇不得不吐槽下百度&#xff0c;百度智能云平台首页跳转千帆大模型平台的按钮太多了&#xff0c;不同按钮跳转不同的子页面&#xff0c;不熟悉的&#xff0c;能把人找懵。入口太多&#xff0c;就导致用户不知道从何开始。本文就从一个前端开发人员的角度&#xff0c;教大家快…
阅读更多...
【Golang】解决使用interface{}解析json数字会变成科学计数法的问题

【Golang】解决使用interface{}解析json数字会变成科学计数法的问题

在使用解析json结构体的时候&#xff0c;使用interface{}接数字会发现变成了科学计数法格式的数字&#xff0c;不符合实际场景的使用要求。 举例代码如下&#xff1a; type JsonUnmStruct struct {Id interface{} json:"id"Name string json:"name"…
阅读更多...
查询Greenplum的视图和存储过程，指定schema

查询Greenplum的视图和存储过程，指定schema

查询视图 SELECT schemaname,viewname AS view_name, definition AS view_definition FROM pg_views WHERE schemaname dcf_user; 查询存储过程 SELECT a.proname ,a.prosrc ,b.rolname FROM pg_proc a left join pg_roles b on a.proowner b.oid where b.rolname dcf…
阅读更多...
【SpringCloud】微服务架构设计模式

【SpringCloud】微服务架构设计模式

一、聚合气微服务设计模式 最常见、最简单的设计模式&#xff0c;效果如图所示&#xff1a; 聚合器调用多个服务实现应用程序所需的功能 它可以是一个简单的 Web 页面&#xff0c;将检索到的数据进行处理并展示&#xff0c;也可以是一个更高层次的组合微服务&#xff0c;对…
阅读更多...
OpenAI研发神秘“Q*”模型：科学家认输，AI赢了人类关键一战

OpenAI研发神秘“Q*”模型：科学家认输，AI赢了人类关键一战

图片来源&#xff1a;视觉中国 作者丨叶蓁 编辑丨康晓 出品丨深网腾讯新闻小满工作室 在山姆奥特曼&#xff08;Sam Altman&#xff09;被OpenAI前董事会突然罢免之前&#xff0c;数位研究人员向董事会发送了一封信&#xff0c;警告称他们发现了一种能够威胁到人类的强大人工…
阅读更多...
护眼灯值不值得买？央视力推五款护眼台灯推荐

护眼灯值不值得买？央视力推五款护眼台灯推荐

为了预防孩子近视&#xff0c;台灯已经成为许多家庭的标配。然而&#xff0c;灯光是一种看得见摸不着的商品&#xff0c;导致家长们选购台灯的核心指标可能只有两个&#xff1a;价格以及亮度。但很明显&#xff0c;这两项指标并不能决定台灯是否护眼。如果家长们不了解具体的判…
阅读更多...
学习ComplexHeatmap复杂热图

学习ComplexHeatmap复杂热图

iMeta | 复杂热图(ComplexHeatmap)可视化文章最新版&#xff0c;画热图就引它_生信宝典的博客-CSDN博客 作者贡献 顾祖光&#xff1a;研究课题的提出和设计&#xff0c; 软件编写&#xff0c;可视化&#xff0c;数据分析&#xff0c;论文编写&#xff0c;修订和审阅。 代码和…
阅读更多...
FIB表与快速转发表工作原理

FIB表与快速转发表工作原理

在一张路由表中&#xff0c;当存在多个路由项可同时匹配目的IP地址时&#xff0c;路由查找进程会选择掩码最长的路由项用于转发&#xff0c;即最长匹配原则。因为掩码越长&#xff0c;所处的网段范围就越小&#xff0c;网段的范围越小&#xff0c;就越能快速的定位到PC机的具体…
阅读更多...
AC自动机（简单模板）

AC自动机（简单模板）

AC自动机&#xff0c;就相当于是在字典树上用kmp。next数组回退的位置为最大匹配字符串在字典树上的节点位置。 在获取字典树上的next数组的时候用的是BFS每次相当与处理的一层。 下图中红线为&#xff0c;可以回退的位置&#xff0c;没有红线的节点回退的位置都是虚拟原点。…
阅读更多...
最新文章

Copyright @ 2022~2023