JavaEE之多线程(创建线程的五种写法)详解

😽博主CSDN主页: 小源_😽

🖋️个人专栏: JavaEE

😀努力追逐大佬们的步伐~

目录

1. 前言 

2. 操作系统"内核"

3. 创建线程的五种写法 (我们重点要掌握最后一种写法!!)

3.1 继承 Thread, 重写 run

3. 2 实现 Runnable 接口, 重写 run

3.3 继承 Thread, 重写 run, 使用匿名内部类

3.4 实现 Runnable, 重写 run, 使用匿名内部类

3.5  [常用/推荐] 使用 lambda 表达式

4. 小结

1. 前言 

我们在写代码的时候, 可以使用多进程进行并发编程, 也可以使用多线程并发编程.

但是多进程并发编程在 Java 中不太推荐, 因为很多和多进程编程相关的 api 在 Java 标准库中都没有提供, 并且在上篇文章中我们讲解了多线程并发编程时效率更高(在需要频繁创建和销毁进程的时候), 并且对于 Java 进程, 需要启动 Java 虚拟机, 导致开销更大 (搞多个 Java 进程就是搞多个 Java 虚拟机)

而系统提供了多线程编程的 api, Java 标准库中把这些 api 封装了, 在代码中可以直接使用. 我们重点学习 Thread 这样的类

本章重点：

本文着重讲解了创建线程的五种写法

2. 操作系统"内核"

我们在学习创建线程之前, 需要先了解操作系统"内核", 它是操作系统中最核心的模块 (用来管理与硬件和给软件提供稳定的运行环境)

操作系统有两个状态: 内核态和用户态, 并且各有自己的空间 (内核空间, 用户空间)

比如我们平时运行的普通的应用程序 (如 idea, java, 画图板, qq音乐......) 都是运行在用户态的, 当操作这些从程序时, 不是应用程序直接操作的, 而是需要调用系统的 api, 在内核中完成操作

为什么要划分出这两个状态呢??

最主要的目的是为了 "稳定": 防止你的应用程序破坏硬件设备或者软件资源

系统封装了一些 api, 这些 api 都是一些合法的操作, 应用程序只能调用这些 api, 就不至于对系统火与硬件设备产生危害 (如果应用程序可以直接操作硬件, 极端情况下, 代码出现 bug, 可能把硬件烧坏)

3. 创建线程的五种写法 (我们重点要掌握最后一种写法!!)

每个线程都是一个独立的执行流, 每个线程都能够独立的去 cpu 上调度执行

3.1 继承 Thread, 重写 run

  1. 创建一个自己的类, 继承自这个 Thread
  2. 根据刚才的类, 创建出实例
  3. 调用 Thread 的 start 方法 
package thread;

// 1. 创建一个自己的类, 继承自这个 Thread
    // 这个 Thread 类能直接使用, 不需要导入包, 是因为 Java 标准库中, 有一个特殊的包 java.long, 和 String 类似 (也在 java.long 包中)
class MyThread extends Thread {
    // 这里重写的 run 入口方法必须手动指定, 针对原有的 Thread 进行扩展 (把一些能复用的复用, 需要扩展的扩展)
    @Override
    public void run() {
        // run 方法就是该线程的入口方法. 和 main 方法类似, main 方法是一个进程的入口方法 (也可以说 main 方法是主线程的入口方法)
        // 一个进程至少有一个线程, 这个进程中的第一个线程就叫做"主线程", 如果一个进程只有一个线程, 即 main 线程就是主线程
        System.out.println("hello world");
    }
}

public class ThreadDemo1 {
    public static void main(String[] args) {
        // 2. 根据刚才的类, 创建出实例. (线程实例,才是真正的线程).
        MyThread t = new MyThread();
        // Thread t = new MyThread();
        // 3. 调用 Thread 的 start 方法, 才会真正调用系统的 api, 在系统内核中创建出线程, 然后线程就会执行上面的 run 方法了
        t.start();
    }
}

按照之前的理解 (没有学习多线程之前), 如果一个代码出现了死循环, 最多只能执行一个, 另一个循环是进不去的, 下面我们来创建两个线程

package thread;

class MyThread2 extends Thread {
    @Override
    public void run() {
        while (true) {
            System.out.println("hello thread");

            // (我们使用的 sleep 是 Java 中封装后的版本, 是 Thread 提供的静态方法) 加 sleep 来降低循环的速度 (这里让 t 线程睡眠 1s (1000ms 等于 1s)), 先写第 19 行代码把鼠标指针放在 sleep 上, 按 Alt + Enter 即可
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

public class ThreadDemo2 {
    public static void main(String[] args) {
        Thread t = new MyThread2();

        t.start();

        while (true) {
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

两个线程都在执行, 互不干扰, 运行结果为: 

我们可以发现:  每一秒打印的顺序都是随机的, 这里涉及到一个重要结论, 当一个进程中有多个线程时, 这些线程执行的先后顺序, 是完全随机的. (因为操作系统内核中, 有一个"调度器" 模块, 这个模块的实现方式类似 "随机调度" 的效果)

什么是"随机调度": 

  1. 一个进程什么时候被调度到 cpu 上执行的时机是不确定的
  2. 一个线程什么时候从 cpu 上下来, 给别人让位的时机也是不确定的

这是主流操作系统"抢占式执行"的体现, 但是给我们的多线程的安全问题埋下了伏笔

刚才我们只是通过打印的方式看到了两个执行流, 我们也可以使用一些第三方工具更直观地看到多个线程的情况

在 jdk 中, 有一个叫 jconsole 的工具 

选择本地进程中我们刚刚执行的 ThreadDemo2 代码, 然后直接连接即可, 

直接选择不安全的连接即可

线程是在正在不停的运行的, 当我们点击 Thread-0 线程的详细情况的一瞬间, 相当于"咔嚓"一个快照把这一瞬间的 Thread-0 线程的状态展示出来了 (再次点击时, 线程的详细情况可能会改变)

这里的"堆栈跟踪", 就是线程的调用栈, 描述了线程当前执行到哪个方法的第几行代码, 以及这个方法是如何一层一层调用过去的

除了 main 线程和 t 线程, 其余的线程都是 JVM 自带的线程, 完成一些垃圾回收, 以及监控统计各种指标 (如果我们的代码出现问题, 就可以从中提取一些参考和线索), 把统计指标通过网络的方式, 传输给其他程序,

 

3. 2 实现 Runnable 接口, 重写 run

只是实现接口时改变, 其余和上面的代码类似

package thread;

// Runnable 可理解为 "可执行的", 通过这个接口, 就可以抽象出一段可以被其他实体执行的代码
class MyThread3 implements Runnable {
    @Override
    public void run() {
        while (true) {
            System.out.println("hello runnable");
            
            //睡眠 1s
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

public class ThreadDemo3 {
    public static void main(String[] args) {
        Thread t = new Thread(new MyThread3());

        t.start();

        while (true) {
            System.out.println("hello main");

            //睡眠 1s
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

3.3 继承 Thread, 重写 run, 使用匿名内部类

内部类是在一个类里面定义的类, 最多使用的就是匿名内部类 (这个类没有名字, 不能重复使用, "用一次就扔掉")

package thread;

public class ThreadDemo4 {
    public static void main(String[] args) {
        // 写 { 是因为要定义一个新的类, 继承自 Thread, {} 中定义子类的属性和方法, 此处最主要的目的是重写 run 方法
        // t 指向的实例不是单纯的 Thread, 而是新定义的匿名内部类 (Thread 的子类)
        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();

        while (true) {
            System.out.println("hello main");
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

3.4 实现 Runnable, 重写 run, 使用匿名内部类

package thread;

public class ThreadDemo5 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            // Thread 构造的方法的参数, 填写了 Runnable 的匿名内部类的实例
            @Override
            public void run() {
                while (true) {
                    System.out.println("hello runnable");
                    
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                }
            }
        });
        
        t.start();

        while (true) {
            System.out.println("hello main");
            
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

3.5  [常用/推荐] 使用 lambda 表达式

这是最简洁的写法

lambda 主流语言都有: c++, Python 中叫做 lambda, JS, GO 直接叫做匿名函数

因为方法不能脱离类单独存在, 所以导致上面几种方法为了设置回调函数 而套上了一层类

因此引入了 lambda 表达式 (就是一个匿名函数/方法), Java语法首创, 函数式接口属于 lambda 背后的实现, 相当于在没有破坏原有规则 (方法不能脱离类单独存在) 的基础上, 给了lambda 一个合理的解释

package thread;

public class ThreadDemo6 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            System.out.println("hello thread");
            
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });

        t.start();

        while (true) {
            System.out.println("hello main");
            
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        }
    }
}

4. 小结

上述的5种写法都是等价的, 可以互相转换的, 用 lambda 表达式是我们最常用, 最推荐, 最简洁的写法

最后，祝大家天天开心，更上一层楼！关注我🌹，我会持续更新学习分享...🖋️

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

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

相关文章

北京保险服务中心携手镜舟科技，助推新能源车险市场规范化

北京保险服务中心携手镜舟科技，助推新能源车险市场规范化

2022 年，一辆新能源汽车在泥泞的小路上不慎拖底，动力电池底壳受损，电池电量低。车主向保险公司报案，希望能够得到赔偿。然而，在定损过程中，保司发现这辆车的电池故障并非由拖底事件引起，而是由于…
阅读更多...
电脑坏了去维修，第一家报价800,第三家说报废！

电脑坏了去维修，第一家报价800,第三家说报废！

这篇文章主要讲的是修理坏掉的电脑。 第一家报价300，第二家报价800，第三家说要报废！ 相信很多朋友对于修电脑坏了要多少钱有很多困惑，修电脑坏了要多少钱，到底去正规售后服务还是去非品牌店维修一台坏掉的电脑。 今天高…
阅读更多...
基于单片机的电子琴设计

基于单片机的电子琴设计

基于单片机的电子琴设计 摘 要 读书、看电影、听音乐，都是最常见的丰富内心世界的良剂。听音乐，作为陶冶情操、提升境界最便捷的方式，正受到越来越多人们的欢迎。音乐可以很轻松的融入各种场合，给人们带来很轻松的氛围&#xff…
阅读更多...
基础---nginx 启动不了，跟 Apache2 服务冲突

基础---nginx 启动不了，跟 Apache2 服务冲突

文章目录 查看 nginx 服务状态nginx 启动后 访问页面 127.0.0.1停止 nginx 服务，访问不了页面停止/启动 Apache2 服务，启动 Apache2 页面访问显示正确nginx 莫名启动不了卸载 Apache2 服务器 启动 nginx ，但是总是不能实现反向代理&#xff0…
阅读更多...
微服务分布式springcloud的体育场地预约系统演kdm1z

微服务分布式springcloud的体育场地预约系统演kdm1z

体育场馆设施预约系统是在实际应用和软件工程的开发原理之上，运用java语言以及Springcloud框架进行开发。首先要进行需求分析，分析出体育场馆设施预约系统的主要功能，然后设计了系统结构。整体设计包括系统的功能、系统总体结构、系统数据结构…
阅读更多...
Annaconda环境下ChromeDriver配置及爬虫编写

Annaconda环境下ChromeDriver配置及爬虫编写

Anaconda环境的chromedriver安装配置_anaconda 配置chromedriver-CSDN博客 Chromedriver驱动( 121.0.6167.85 ) - 知乎 下载好的驱动文件解压，将exe程序复制到Annaconda/Scripts目录以及Chrome/Application目录下 注意要提前pip install selenium包才能运行成功&a…
阅读更多...
若依Vue3图片预览大图遮罩层和表格的border css层级冲突

若依Vue3图片预览大图遮罩层和表格的border css层级冲突

样式层级出现问题，表格的层级高于图片的层级 1.解决方式一：设置此文件的该属性（z-index）为继承，则显示正常 .el-table .el-table__cell { z-index: inherit; } 2.解决方式二：将此属性设置为true(本人试了…
阅读更多...
【Python】快捷找到最大最小 N 个元素

【Python】快捷找到最大最小 N 个元素

heapq 简单数据结构取出最大最小N个元素复杂数据结构中取出最大最小N个元素代码解析：lambda Python 中有 heapq 模块可以快捷找到数组中最大最小的 N 个元素； heapq.nlargest(num, arr) # 从arr数组中取出最大num个元素 heapq.nsmallest(num, arr) # …
阅读更多...
[论文笔记]LLaMA: Open and Efficient Foundation Language Models

[论文笔记]LLaMA: Open and Efficient Foundation Language Models

引言 今天带来经典论文 LLaMA: Open and Efficient Foundation Language Models 的笔记，论文标题翻译过来就是 LLaMA:开放和高效的基础语言模型。 LLaMA提供了不可多得的大模型开发思路，为很多国产化大模型打开了一片新的天地，论文和代码值…
阅读更多...
npm报错，显示certificate has expired

npm报错，显示certificate has expired

从报错信息就可以知道是因为之前设置的淘宝镜像已过期，解决方法就是要把之前设置的淘宝镜像改成新的 第一种方法 第一步：清空缓存 npm cache clean --force第二步：重新设置新的镜像源 npm config set registry https://registry.npmmirror…
阅读更多...
使用canvas实现图纸标记及回显

使用canvas实现图纸标记及回显

图纸 图纸标记后的效果图 最近做的一个qms项目里面，需要前端在图纸上实现标记及标记后的内容还要能够回显，然后后端通过标记的点，去读取标记图纸的内容，如一些公式、数据之类的，目前实现的功能有 在图纸上面进行矩形…
阅读更多...
点云配准论文阅读1-Research on Three-Dimensional Point Cloud Registration Algorithm

点云配准论文阅读1-Research on Three-Dimensional Point Cloud Registration Algorithm

Research on Three-Dimensional Point Cloud Registration Algorithm三维点云配准算法研究 Publisher: IEEE发行者 ： IEEE Cite This引用此内容 PDF Yuqing Zhang; Shilong Sun; Jingjing Shang; Minghan Yang张玉清;孙世龙; 尚晶晶;杨明翰 Abstract: Accordi…
阅读更多...
88. 合并两个有序数组 (Swift版本)

88. 合并两个有序数组 (Swift版本)

题目 给你两个按 非递减顺序 排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。 请你 合并 nums2 到 nums1 中，使合并后的数组同样按 非递减顺序 排列。 注意：最终，合并…
阅读更多...
【C++ 设计模式】简单工厂模式

【C++ 设计模式】简单工厂模式

文章目录 前言一、简单工厂模式是什么？二、实现原理三、UML类图四、简单工厂模式具体代码总结 前言 在软件开发中，设计模式是解决特定问题的可复用解决方案。其中，简单工厂模式是一种创建型设计模式，旨在封装对象的创建过程&…
阅读更多...
Python数学建模-2.3函数（下）

Python数学建模-2.3函数（下）

2.3.2模块的导入与使用 模块在Python中是一个包含Python定义和语句的文件，通常用来组织代码，使得代码更易于管理和复用。下面，我将详细讲解Python函数中模块的使用知识。 1. 模块的导入 在Python中，你可以使用import语句来导入…
阅读更多...
PyCharm创建一个简单的Django项目

PyCharm创建一个简单的Django项目

1.Django简介 Django 是一个开放源代码的 Web 应用程序框架，由 Python 编写而成。它遵循 MVC（模型-视图-控制器）的软件设计模式，采用了 MTV（模型-模板-视图）的架构。Django 的设计目标是使开发复杂的、数据…
阅读更多...
java maven聚合项目-子项目重写父项目的依赖版本无法生效

java maven聚合项目-子项目重写父项目的依赖版本无法生效

前言 项目的springboot版本2.6.13 项目主pom 引入了springboot的依赖配置 <dependencyManagement><dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-dependencies</artifactId><…
阅读更多...
华为OD技术C卷“测试用例执行计划”Java解答

华为OD技术C卷“测试用例执行计划”Java解答

描述 示例 算法思路1 整体思路是&#xff0c;先读取特性的优先级和测试用例覆盖的特性列表&#xff0c;然后计算每个测试用例的优先级&#xff0c;并将其与测试用例的索引存储到二维数组中。最后按照优先级和索引排序&#xff0c;输出测试用例的索引&#xff0c;即为执行顺序。…
阅读更多...
【计算机视觉】二、图像形成：1、向量和矩阵的基本运算：线性变换与齐次坐标

【计算机视觉】二、图像形成：1、向量和矩阵的基本运算：线性变换与齐次坐标

文章目录 一、向量和矩阵的基本运算1、简单变换1. 平移变换2. 缩放变换3. 旋转变换4. 一般线性变换 2、齐次坐标0. 齐次坐标表示1. 2D点的齐次坐标变换2. 投影空间 ( x , y , w ) (x, y, w) (x,y,w)3. 2D直线的齐次坐标表示a. 直线的参数方程表示b. 直线的法向量和原点距离表示…
阅读更多...
Maven3.6.3安装与配置，IDEA2022.2.3部署Maven操作步骤

Maven3.6.3安装与配置，IDEA2022.2.3部署Maven操作步骤

1、先确保安装了Java开发环境&#xff0c;并配置了JAVA_HOME环境变量 WinR ,输入cmd,然后输入命令echo %JAVA_HOME%,查看JDK &#xff0c;接着输入java -version,查看java的版本号 接着系统变量中&#xff0c;配置JAVA_HOME环境变量 2、官网下载MAVEN3.6.3&#xff0c;Maven3.…
阅读更多...
最新文章

Copyright @ 2022~2023