Java多线程：Thread中的实例方法

Thread类中的方法调用方式：

学习Thread类中的方法是学习多线程的第一步。在学习多线程之前特别提出一点，调用Thread中的方法的时候，在线程类中，有两种方式，一定要理解这两种方式的区别：

1、this.XXX()

这种调用方式表示的线程是线程实例本身

2、Thread.currentThread.XXX()或Thread.XXX()

上面两种写法是一样的意思。这种调用方式表示的线程是正在执行Thread.currentThread.XXX()所在代码块的线程

当然，这么说，肯定有人不理解两者之间的差别。没有关系，之后会讲清楚，尤其是在讲Thread构造函数这块。讲解后，再回过头来看上面2点，会加深理解。

Thread类中的实例方法

从Thread类中的实例方法和类方法的角度讲解Thread中的方法，这种区分的角度也有助于理解多线程中的方法。实例方法，只和实例线程（也就是new出来的线程）本身挂钩，和当前运行的是哪个线程无关。看下Thread类中的实例方法：

1、start()

start()方法的作用讲得直白点就是通知"线程规划器"，此线程可以运行了，正在等待CPU调用线程对象得run()方法，产生一个异步执行的效果。通过start()方法产生得到结论，先看下代码：

public class MyThread02 extends Thread{

    public void run()

    {

        try{

            for (int i = 0; i < 3; i++){

                Thread.sleep((int)(Math.random() * 1000));

                System.out.println("run = " + Thread.currentThread().getName());

            }

        }

        catch (InterruptedException e){

            e.printStackTrace();

        }

    }

}

public static void main(String[] args){

    MyThread02 mt = new MyThread02();

    mt.start();

       

    try{

        for (int i = 0; i < 3; i++){

            Thread.sleep((int)(Math.random() * 1000));

            System.out.println("run = " + Thread.currentThread().getName());

        }

    }

    catch (InterruptedException e){

        e.printStackTrace();

    }

}

看下运行结果：

run = Thread-0

run = main

run = main

run = main

run = Thread-0

run = Thread-0

结果表明了：CPU执行哪个线程的代码具有不确定性。再看另外一个例子：

public class MyThread03 extends Thread {
        public void run() {
            System.out.println(Thread.currentThread().getName());
        }
    }

    public static void main(String[] args) {
        MyThread03 mt0 = new MyThread03();
        MyThread03 mt1 = new MyThread03();
        MyThread03 mt2 = new MyThread03();
        mt0.start();
        mt1.start();
        mt2.start();
    }

看下运行结果：

Thread-1

Thread-2

Thread-0

尽管启动线程是按照mt0、mt1、mt2，但是实际的启动顺序却是Thread-1、Thread-2、Thread-0。这个例子说明了：调用start()方法的顺序不代表线程启动的顺序，线程启动顺序具有不确定性。

2、run()

线程开始执行，虚拟机调用的是线程run()方法中的内容。稍微改一下之前的例子看一下：

public static void main(String[] args) {
        MyThread02 mt = new MyThread02();
        mt.run();
        try {
            for (int i = 0; i < 3; i++) {
                Thread.sleep((int)(Math.random() * 1000));
                System.out.println("run = " + Thread.currentThread().getName());
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

MyThread02的代码不变，看下运行结果：

run = main

run = main

run = main

run = main

run = main

run = main

看到打印了6次的"run = main"，说明如果只有run()没有start()，Thread实例run()方法里面的内容是没有任何异步效果的，全部被main函数执行。换句话说，只有run()而不调用start()启动线程是没有任何意义的。

3、isAlive()

测试线程是否处于活动状态，只要线程启动且没有终止，方法返回的就是true。看一下例子：

 public class MyThread06 extends Thread {
        public void run() {
            System.out.println("run = " + this.isAlive());
        }
    }

    public static void main(String[] args) throws Exception {
        MyThread06 mt = new MyThread06();
        System.out.println("begin == " + mt.isAlive());
        mt.start();
        Thread.sleep(100);
        System.out.println("end == " + mt.isAlive());
    }

看下运行结果：

begin == false

run = true

end == false

看到在start()之前，线程的isAlive是false，start()之后就是true了。main函数中加上Thread.sleep(100)的原因是为了确保Thread06的run()方法中的代码执行完，否则有可能end这里打印出来的是true，有兴趣可以自己试验一下。

4、getId()

这个方法比较简单，就不写例子了。在一个Java应用中，有一个long型的全局唯一的线程ID生成器threadSeqNumber，每new出来一个线程都会把这个自增一次，并赋予线程的tid属性，这个是Thread自己做的，用户无法执行一个线程的Id。

5、getName()

这个方法也比较简单，也不写例子了。我们new一个线程的时候，可以指定该线程的名字，也可以不指定。如果指定，那么线程的名字就是我们自己指定的，getName()返回的也是开发者指定的线程的名字；如果不指定，那么Thread中有一个int型全局唯一的线程初始号生成器threadInitNum，Java先把threadInitNum自增，然后以"Thread-threadInitNum"的方式来命名新生成的线程

6、getPriority()和setPriority(int newPriority)

这两个方法用于获取和设置线程的优先级，优先级高的CPU得到的CPU资源比较多，设置优先级有助于帮"线程规划器"确定下一次选择哪一个线程优先执行。换句话说，两个在等待CPU的线程，优先级高的线程越容易被CU选择执行。下面来看一下例子，并得出几个结论：

public class MyThread09_0 extends Thread {
        public void run() {
            System.out.println("MyThread9_0 run priority = " +
                this.getPriority());
        }
    }

    public class MyThread09_1 extends Thread {
        public void run() {
            System.out.println("MyThread9_1 run priority = " +
                this.getPriority());
            MyThread09_0 thread = new MyThread09_0();
            thread.start();
        }
    }

    public static void main(String[] args) {
        System.out.println("main thread begin, priority = " +
            Thread.currentThread().getPriority());
        System.out.println("main thread end, priority = " +
            Thread.currentThread().getPriority());
        MyThread09_1 thread = new MyThread09_1();
        thread.start();
    }

看一下运行结果：

main thread begin, priority = 5

main thread end, priority = 5

MyThread9_1 run priority = 5

MyThread9_0 run priority = 5

从这个例子我们得出结论：线程默认优先级为5，如果不手动指定，那么线程优先级具有继承性，比如线程A启动线程B，那么线程B的优先级和线程A的优先级相同。

下面的例子演示了设置线程优先级带来的效果：

public class MyThread10_0 extends Thread {
        public void run() {
            long beginTime = System.currentTimeMillis();
            for (int j = 0; j < 100000; j++) {
            }
            long endTime = System.currentTimeMillis();
            System.out.println("◆◆◆◆◆ thread0 use time = " +
                (endTime - beginTime));
        }
    }

    public class MyThread10_1 extends Thread {
        public void run() {
            long beginTime = System.currentTimeMillis();
            for (int j = 0; j < 100000; j++) {
            }
            long endTime = System.currentTimeMillis();
            System.out.println("◇◇◇◇◇ thread1 use time = " +
                (endTime - beginTime));
        }
    }

    public static void main(String[] args) {
        for (int i = 0; i < 5; i++) {
            MyThread10_0 mt0 = new MyThread10_0();
            mt0.setPriority(5);
            mt0.start();
            MyThread10_1 mt1 = new MyThread10_1();
            mt1.setPriority(4);
            mt1.start();
        }
    }

看下运行结果：

◆◆◆◆◆ thread0 use time = 0

◆◆◆◆◆ thread0 use time = 0

◆◆◆◆◆ thread0 use time = 1

◆◆◆◆◆ thread0 use time = 2

◆◆◆◆◆ thread0 use time = 2

◇◇◇◇◇ thread1 use time = 0

◇◇◇◇◇ thread1 use time = 1

◇◇◇◇◇ thread1 use time = 5

◇◇◇◇◇ thread1 use time = 2

◇◇◇◇◇ thread1 use time = 0

看到黑色菱形（线程优先级高的）先打印完，再多试几次也是一样的。为了产生一个对比效果，把yMyThread10_0的优先级设置为4，看下运行结果：

◆◆◆◆◆ thread0 use time = 0

◇◇◇◇◇ thread1 use time = 1

◇◇◇◇◇ thread1 use time = 1

◆◆◆◆◆ thread0 use time = 0

◇◇◇◇◇ thread1 use time = 0

◆◆◆◆◆ thread0 use time = 1

◆◆◆◆◆ thread0 use time = 1

◇◇◇◇◇ thread1 use time = 2

◇◇◇◇◇ thread1 use time = 1

◆◆◆◆◆ thread0 use time = 0

看到，马上差别就出来了。从这个例子我们得出结论：CPU会尽量将执行资源让给优先级比较高的线程。

7、isDaeMon、setDaemon(boolean on)

讲解两个方法前，首先要知道理解一个概念。Java中有两种线程，一种是用户线程，一种是守护线程。守护线程是一种特殊的线程，它的作用是为其他线程的运行提供便利的服务，最典型的应用便是GC线程。如果进程中不存在非守护线程了，那么守护线程自动销毁，因为没有存在的必要，为别人服务，结果服务的对象都没了，当然就销毁了。理解了这个概念后，看一下例子：

public class MyThread11 extends Thread {
        private int i = 0;

        public void run() {

            try {

                while (true) {

                    i++;

                    System.out.println("i = " + i);

                    Thread.sleep(1000);

                }

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

    public static void main(String[] args) {

        try {

            MyThread11 mt = new MyThread11();

            mt.setDaemon(true);

            mt.start();

            Thread.sleep(5000);

            System.out.println("我离开thread对象再也不打印了，我停止了！");

        } catch (InterruptedException e) {

            e.printStackTrace();

        }

    }

看一下运行结果：

i = 1

i = 2

i = 3

i = 4

i = 5

我离开thread对象再也不打印了，我停止了！

i = 6

要解释一下。我们将MyThread11线程设置为守护线程，看到第6行的那句话，而i停在6不会再运行了。这说明，main线程运行了5秒多结束，而i每隔1秒累加一次，5秒后main线程执行完结束了，MyThread11作为守护线程，main函数都运行完了，自然也没有存在的必要了，就自动销毁了，因此也就没有再往下打印数字。

关于守护线程，有一个细节注意下，setDaemon(true)必须在线程start()之前

8、interrupt()

这是一个有点误导性的名字，实际上Thread类的interrupt()方法无法中断线程。看一下例子：

public class TestMain12_0 {

        public static void main(String[] args) {

            try {

                MyThread12 mt = new MyThread12();

                mt.start();

                Thread.sleep(2000);

                mt.interrupt();

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

public void run() {

        for (int i = 0; i < 500000; i++) {

            System.out.println("i = " + (i + 1));

        }

    }

看下运行结果：

...

i = 499995

i = 499996

i = 499997

i = 499998

i = 499999

i = 500000

看结果还是打印到了50000。也就是说，尽管调用了interrupt()方法，但是线程并没有停止。interrupt()方法的作用实际上是：在线程受到阻塞时抛出一个中断信号，这样线程就得以退出阻塞状态。换句话说，没有被阻塞的线程，调用interrupt()方法是不起作用的。关于这个会在之后讲中断机制的时候，专门写一篇文章讲解。

9、isInterrupted()

测试线程是否已经中断，但不清除状态标识。这个和interrupt()方法一样，在后面讲中断机制的文章中专门会讲到。

10、join()

讲解join()方法之前请确保对于wait()/notify()/notifyAll()机制已熟练掌握。

join()方法的作用是等待线程销毁。join()方法反应的是一个很现实的问题，比如main线程的执行时间是1s，子线程的执行时间是10s，但是主线程依赖子线程执行完的结果，这时怎么办？可以像生产者/消费者模型一样，搞一个缓冲区，子线程执行完把数据放在缓冲区中，通知main线程，main线程去拿，这样就不会浪费main线程的时间了。另外一种方法，就是join()了。先看一下例子：

public class MyThread36 extends Thread {

        public void run() {

            try {

                int secondValue = (int)(Math.random() * 10000);

                System.out.println(secondValue);

                Thread.sleep(secondValue);

            } catch (InterruptedException e) {

                e.printStackTrace();

            }

        }

    }

    public static void main(String[] args) throws Exception {

        MyThread36 mt = new MyThread36();

        mt.start();

        mt.join();

        System.out.println("我想当mt对象执行完毕之后我再执行，我做到了");

    }

看一下运行结果：

3111

我想当mt对象执行完毕之后我再执行，我做到了

意思是，join()方法会使调用join()方法的线程（也就是mt线程）所在的线程（也就是main线程）无限阻塞，直到调用join()方法的线程销毁为止，此例中main线程就会无限期阻塞直到mt的run()方法执行完毕。

join()方法的一个重点是要区分出和sleep()方法的区别。join(2000)也是可以的，表示调用join()方法所在的线程最多等待2000ms，两者的区别在于：

sleep(2000)不释放锁，join(2000)释放锁，因为join()方法内部使用的是wait()，因此会释放锁。看一下join(2000)的源码就知道了，join()其实和join(2000)一样，无非是join(0)而已：

public final synchronized void join(long millis)

        throws InterruptedException {

        long base = System.currentTimeMillis();

        long now = 0;

        if (millis < 0) {

            throw new IllegalArgumentException("timeout value is negative");

        }

        if (millis == 0) {

            while (isAlive()) {

                wait(0);

            }

        } else {

            while (isAlive()) {

                long delay = millis - now;

                if (delay <= 0) {

                    break;

                }

                wait(delay);

                now = System.currentTimeMillis() - base;

            }

        }

    }

第12行、第20行应该已经很清楚了

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

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

相关文章

python 生成器、迭代器、动态新增属性及方法

python 生成器、迭代器、动态新增属性及方法

目录 一、生成器 1、生成器定义 2、生成器存在的意义 3、创建生成器方式一&#xff08;生成器表达式&#xff09; 4. 创建生成器方式二&#xff08;生成器函数&#xff09; 1. 生成器函数 2. 生成器函数的工作原理 5. 总结 1. 什么是生成器 2. 生成器特点 二、迭代器…
阅读更多...
365天深度学习训练营-第J8周：Inception v1算法实战与解析

365天深度学习训练营-第J8周：Inception v1算法实战与解析

目录 一、前言 二、论文解读 1. Inception 模块 2. 网络深度问题 3. 全局平均池化 4. 卷积层的并行结构 5. 1x1 卷积核 6.详细的网络结构 三、代码复现 一、前言 &#x1f368; 本文为&#x1f517;365天深度学习训练营 中的学习记录博客&#x1f356; 原作者&#x…
阅读更多...
微服务+springcloud+springcloud alibaba学习笔记【Eureka服务注册中心】(3/9)

微服务+springcloud+springcloud alibaba学习笔记【Eureka服务注册中心】(3/9)

Eureka服务注册中心 3/91、服务注册与发现1.1 什么是服务治理&#xff1a;1.2 什么是服务注册与发现&#xff1a;1.3 Eureka服务注册与发现2、单机版eureka2.1 创建module2.2改pom依赖2.3写yml配置文件:2.4主启动类2.5 修改服务提供者 cloud-provider-payment8001 模块&#xf…
阅读更多...
Github库中的Languages显示与修改

Github库中的Languages显示与修改

目录 前言 【.gitattributes】文件 修改GitHub语言 前言 上传一个项目到GitHub时&#xff0c;发现显示的语言并非是自己项目所示的语言&#xff0c;这样的情况是经常发生的&#xff0c;为了能到达自己所需快速检索&#xff0c;或者是外部访问者能很好的搜索我们的项目&#…
阅读更多...
Sentinel滑动时间窗限流算法原理及源码解析（中）

Sentinel滑动时间窗限流算法原理及源码解析（中）

文章目录 MetricBucketMetricEvent数据统计的维度WindowWrap样本窗口实例 范型T为MetricBucket windowLengthInMs 样本窗口长度 windowStart 样本窗口的起始时间戳 value 当前样本窗口的统计数据 其类型为MetricBucket MetricBucket MetricEvent数据统计的维度 1、首先计算27t位…
阅读更多...
【花雕学AI】09：发挥ChatGPT最大潜力——产生高质量内容的九种方法和建议

【花雕学AI】09：发挥ChatGPT最大潜力——产生高质量内容的九种方法和建议

人工智能&#xff08;AI&#xff09;是当今科技领域最热门和最有前景的话题之一&#xff0c;它已经渗透到了我们生活和工作的方方面面&#xff0c;给我们带来了许多便利和惊喜。而在AI的众多分支中&#xff0c;自然语言处理&#xff08;NLP&#xff09;是最贴近人类的一个领域&…
阅读更多...
6-python异常、错误、模块、包

6-python异常、错误、模块、包

文章目录1.异常2.错误3.模块4.包[综合练习]1.异常 打开一个不存在的文件会引发异常 FileNotFoundError: [Errno 2] No such file or directory: ‘D:/不存在的文件.txt’ fopen(file"D:/不存在的文件.txt",mode"r", encodingutf-8) print(f.read())&…
阅读更多...
springboot-gateway注册nacos失败，控制台没有报错

springboot-gateway注册nacos失败，控制台没有报错

目录 前言现象描述前言 最近springboot的gateway注册到nacos上，没有注册成功 现象描述 我是在common里面引入了nacos的依赖，依赖如下： <dependency><groupId>com.alibaba.cloud</groupId><artifactId>spring-cloud-starter-alibaba-nacos-confi…
阅读更多...
文件的随机读写

文件的随机读写

fseek fseek这个函数的作用是什么&#xff1f; 我们知道&#xff0c;如果对一个文件指针进行加减操作的话&#xff0c;这个文件指针会指向下一个文件&#xff0c;那么问题来了&#xff0c;我们如果想访问这个文件中的某一个内容&#xff0c;这个时候该怎么办呢&#xff0c;我们…
阅读更多...
基于支持向量机SVM的脑部肿瘤识别，脑电波样本熵提取

基于支持向量机SVM的脑部肿瘤识别，脑电波样本熵提取

目录 支持向量机SVM的详细原理 SVM的定义 SVM理论 Libsvm工具箱详解 简介 参数说明 易错及常见问题 SVM应用实例，基于SVM的的脑部肿瘤识别分类预测 代码 结果分析 展望 支持向量机SVM的详细原理 SVM的定义 支持向量机（support vector machines, SVM）是一种二分类模型，它…
阅读更多...
下一代的新操作系统就是ChatGPT！

下一代的新操作系统就是ChatGPT！

什么是CHatgpt&#xff1f; ChatGPT是人工智能研究实验室OpenAI在2022年11月30日推出的聊天机器人模型&#xff0c;它使用Transformer神经网络架构&#xff0c;训练数据来自包括维基百科&#xff0c;以及真实对话在内的庞大语料库。2023年1月30日消息称&#xff0c;中国搜索巨…
阅读更多...
数据分析-统计基础

数据分析-统计基础

day1&#xff1a;集中趋势&#xff0c;离散测度&#xff0c;均值&#xff0c;中位数&#xff0c;众数&#xff0c;方差等。点估计&#xff0c;区间估计等相关的知识 现代数据分析&#xff1a;把数据放到一个数据空间中&#xff0c;通过这个空间的个各种形变与分析而挖掘除数据…
阅读更多...
Android RenderScript 浅谈

Android RenderScript 浅谈

前言 RenderScript是一个Google出品的&#xff0c;在Android平台上的并行计算框架&#xff0c;官方的简介是说RenderScript运行时可在设备上提供的多个处理器&#xff08;如多核 CPU 和 GPU&#xff09;间并行调度工作。在日常Android开发中&#xff0c;RenderScript主要用于图…
阅读更多...
数据库:Redis哨兵及cluster集群部署

数据库:Redis哨兵及cluster集群部署

一、redis数据库哨兵模式 目录 一、redis数据库哨兵模式 1、什么是哨兵模式 2、哨兵的作用 3、哨兵结构组成 4、哨兵故障转移机制 5、哨兵工作、切换原理 6、哨兵主节点选举原则 7、哨兵模式部署 二、redis数据库cluster集群 1、cluster集群优点、数据存储及同步方式…
阅读更多...
Chapter2 : SpringBoot配置

Chapter2 : SpringBoot配置

尚硅谷SpringBoot顶尖教程 1. 全局配置文件 SpringBoot使用一个全局的配置文件 application.properties 或者 application.yml &#xff0c;该配置文件放在src/main/resources目录或者类路径/config目录下面&#xff0c; 可以用来修改SpringBoot自动配置的默认值。 yml是YA…
阅读更多...
wxml模板，wxss模版，全局配置，页面配置，网络数据请求

wxml模板，wxss模版，全局配置，页面配置，网络数据请求

WXML 模板语法 1、数据绑定 1.1、数据绑定的基本原则 ① 在 data 中定义数据② 在 WXML 中使用数据 1.2、在 data 中定义页面的数据 在页面对应的 .js 文件中&#xff0c;把数据定义到 data 对象中即可&#xff1a; Page({data: {//字符串数据info:init data}, });1.3、M…
阅读更多...
《Kubernetes部署篇：Ubuntu20.04基于containerd部署kubernetes1.24.12单master集群》

《Kubernetes部署篇：Ubuntu20.04基于containerd部署kubernetes1.24.12单master集群》

一、架构图 如下图所示&#xff1a; 二、环境信息 主机名K8S版本系统版本内核版本IP地址备注k8s-master-621.24.12Ubuntu 20.04.5 LTS5.15.0-69-generic192.168.1.62master节点k8s-worker-631.24.12Ubuntu 20.04.5 LTS5.15.0-69-generic192.168.1.63worker节点k8s-worker-641…
阅读更多...
二、SDN-计算机网络专项（2）

二、SDN-计算机网络专项（2）

1、编码 编码形式&#xff1a; 以太网使用的编码方式为曼彻斯特编码。 2、信息传输速率 &#xff08;1&#xff09;香农定理 带宽为W&#xff08;Hz&#xff09;且有高斯噪音干扰&#xff08;信噪比S/N&#xff09;的信道极限信息传输速率为&#xff1a; 还有&#xff0c;信噪…
阅读更多...
Linux_红帽8学习笔记分享_2

Linux_红帽8学习笔记分享_2

Linux_红帽8学习笔记分享_2 文章目录Linux_红帽8学习笔记分享_21.远程控制servera和serverb1.1开启多标签页1.2启用servera和serverb1.3连接servera和serverb2.退出子虚拟机并关机2.1退出子虚拟机2.2关闭虚拟机2.3重启虚拟机3.Linux在使用过程中遇到的基础操作3.1退出至登录界面…
阅读更多...
Spring销毁的几种实现

Spring销毁的几种实现

有这3种方法&#xff0c;但是程序执行完成并没有打印出来。一定要手动close.手动执行后会调用如下逻辑&#xff1a;org.springframework.context.support.AbstractApplicationContext#doCloseorg.springframework.context.support.AbstractApplicationContext#destroyBeansorg.…
阅读更多...
最新文章

Copyright @ 2022~2023

友情链接： 我的编程经验分享 一条长河网 尧图网站开发