Java-线程基础

news2024/9/27 7:25:13

Java 线程详解

一个程序至少需要一个进程，而一个进程至少需要一个线程，它也被称为主线程。

线程是程序执行流的最小单位，而进程是系统进行资源分配和调度的一个最小单位。

在单个进程中，可以拥有多个并发执行的线程，这些线程由CPU调度器分配时间片执行。

0. 线程的实现方式

使用 Thread 类的方式创建线程，写法简单，但不能在继承其他父类。

采用实现 Runnable、Callable 接口的方式创建线程，需要访问当前线程必须使用Thread.currentThread()，不过线程类知识实现了Runnable接口或者Callable接口，还可以继承其他类。多个线程还可以共享同一个target对象，体现了面向对象的思想，适合有设计思想的编程。

  1. 继承Thread类。并重写 run() 方法。

    public class CustomThread extends Thread{
    @Override
    public void run(){
        //设计自定义的线程执行体
    }
}

  2. 通过Runnable接口创建Thread类。

    Thread t1 = new Thread(new Runnable(){
    @Override
    public void run(){
        //设计自定义的线程执行体
    }
});

//lambda表达式写法
Thread t1 = new Thread(()->{
   //设计自定义的线程执行体 
});

  3. 通过Callable和Future创建线程

    • call()方法作为线程的执行体，带有返回值；
    • 用 FutureTask 类来包装 callable 对象；
    • 使用 FutureTask 类作为 Thread 对象的 target 创建并启动新线程；
    • 可以通过 FutureTask 对象的 get() 方法来阻塞等待子线程执行结果。
    public class CallableDemo implements Callable{
    @Override
    public Object call() throws Exception{
        //设计自定义的线程执行体
        return res;
    }
}

public void callableTest(){
    CallableDemo call = new CallableDemo();
    FutureTask<Integer> futureTask = new FutureTask<Integer>(call);
    Thread t = new Thread(futureTask);
    t.start();
    try{
        //同步阻塞等待
        //futureTask.get()阻塞等待线程执行结束返回结果
        System.out.println("Result:"+futureTask.get());
    }catch(Exception e){
        e.printStackTrace();
    }
}

1. 常见方法

方法名说明补充
start(): void启动一个线程，并由JVM调用线程中的 run() 方法线程启动后，再次调用start()是不合法的
run(): void线程要执行的具体任务的方法体通过传入 Runnable 对象或者重写 run() 方法来定制线程任务
sleep(long): void让线程睡眠指定时间线程进入TIMED_WAITING线程状态，唤醒后，视线程调度情况而执行线程任务代码
yield(): void译为“让步”，告知调度器该线程可以交出控制权yield()的让步通知可以被调度器（操作系统）忽略。如果让步成功，线程在Java层面将会保持运行态（RUNNABLE），但在操作系统层面，该线程将从 运行态 变为 就绪态 。
interrupt(): void中断线程.
1. 如果中断的是阻塞态的线程，会清空打断状态（即认为没被打断过）
2. 如果中断的是正常运行的线程，会将打断状态设置为 true。
3. 只有在阻塞态被打断才会抛出异常。		1. 如果线程由 Object#wait(), join() 或者 sleep() 进入阻塞态，被中断时将抛出 InterruptedException 异常
2. 如果线程在I/O阻塞态(java.nio)，I/O会被打断，并抛出 ClosedByInterruptException 异常
3. 如果线程在Selector阻塞态(java.nio)，将会立即停止并返回
interrupted(): boolean判断线程当前是否被中断中断标志将会被清空！
isInterrupted(): boolean判断线程当前是否被中断不影响中断标志

2. 线程状态

2.1 操作系统线程的五大状态

请添加图片描述

  • 初始态(New): 线程对象被创建后，进入初始态，也叫做新建状态。
  • 就绪态(Runnable): 线程已启动，随时可以被 CPU 调度执行。进入就绪态的情况：
    • 运行态–>就绪态：运行态线程由于时间片使用完而被动让出CPU使用权，或者主动让出 CPU 使用权。
    • 阻塞态–>就绪态：阻塞结束，线程被唤醒，进入就绪态。
  • 运行态(Running):线程获取CPU时间片并执行。线程只能从就绪态进入运行态。
  • 阻塞态(Blocked):线程因为某种原因放弃 CPU 使用权，暂时停止运行，直到线程进入就绪态，才有机会转到运行态。在Java中阻塞有三种情况：
    • 等待阻塞——调用线程对象的 wait() 方法，阻塞调用者线程并让出 CPU 使用权，直到被该作为锁的线程对象调用其 notify() 方法。（见Java的 Object#wait() #notify() #notifyAll() 方法）
    • 同步阻塞——线程获取锁失败，进入同步阻塞状态。
    • 其他阻塞——线程调用 sleep() 或者 join() 或者发出 I/O 请求，进入阻塞状态。当 sleep(long) 状态超时、join() 等待线程终止或者超时，或者 I/O 处理完毕，线程可重新进入就绪状态。
  • 死亡态(Dead):线程任务执行完毕，线程结束生命周期。

2.2 Java线程的六大状态

请添加图片描述

  • 初始状态(NEW)：通过 new 关键字新建一个线程。注意，此时的线程只是一个普通的对象引用，操作系统并未创建新的线程。 在构造方法中，仅对线程对象赋予一些属性变量。

  • 运行状态(RUNNING): 线程调用 start() 方法，从初始状态进入就绪状态。此时才真正由操作系统创建一个线程。Java并不能区分线程处在操作系统中的运行态还是就绪态，JVM 将两种状态统一标记为运行态。（在操作系统中对应为 初始态 ，就绪态 与 运行态 ）

    • 运行中–>就绪态：yield() 方法主动让出 CPU 使用权
    • 就绪态–>运行中：系统分配给该线程 CPU 时间片

  • 等待状态(WAITING): 该状态表示当前线程需要等待其他线程做出一些特定动作。（在操作系统中对应为 阻塞态 ）

    • 调用 Object#wait() 方法，调用者让出 CPU 使用权，进入等待状态，直到 锁对象调用 Object#notify() 或者 Object.notifyAll() 唤醒。
    • 在线程执行过程中，调用了其他线程的 join() 方法，需要进入等待状态，阻塞地等待其他线程执行完毕，才可继续当前线程的后续任务。
    • 通过 LockSupport.park() 方法将当前线程阻塞挂起，进入等待状态， 直到 LockSupport.unpark(thread) 唤醒线程并等待被调度。

  • 超时等待状态(TIMED_WAITING): 与 WAITING 不同的是，它可以在指定时间内自行返回。（在操作系统中对应为 阻塞态 ）

    • 通过 Thread.sleep(long) 方法，或者` Object#wait(long) , Object#join(long) 方法进入限时等待状态，如果超过设定时间还未进入运行状态，将会被主动取消阻塞状态，进入运行状态。

      （需要注意的是，虽然进入JVM的 运行态（RUNNABLE），但实际在操作系统中，是进入就绪状态（）Runnable），等待被调度。）

  • 阻塞状态(BLOCKED): 表示当前线程正在等待 Monitor锁（重量级锁）。（在操作系统中对应为 阻塞态 ）

    • 线程等待进入 synchronized 修饰的临界区。线程获取到锁，就会从阻塞状态进入运行态。

      （需要注意的是，虽然进入 JVM 的运行态(RUNNABLE)，但实际在操作系统中，是进入就绪状态(Runnable)，等待被调度。）

  • 终止状态(TERMINATED): 表示线程的 run() 和 call() 已经执行完毕。不能通过 start() 再次唤醒。

3. start() vs run()

start() 方法让操作系统创建并启动一个线程，使得该线程进入操作系统的就绪态。在Java中，进入到运行态。（Java不区分操作系统中的就绪态与运行态）

run() 方法是线程的任务体，它需要被操作系统调用，而不应该由用户主动调用。如果由用户主动调用，run() 方法将会被作为一个普通方法，在调用者的线程中执行，而不是开辟一个新的线程执行它。

可以通过重写 run() 方法，或者初始化线程对象时传入 Runnable 对象，进行线程任务的设计。Thread # run() 源码如下：

//Thread类 实现了 Runnable接口
@Override
public void run(){
    //如果初始化Thread类的时候，传入了Runnable实例，即target，且run()方法并未被重写，则会调用target的run()方法
    if(target != null){
        target.run();
    }
}

4. sleep() vs yield()

主要区别：

  1. 在操作系统层面，sleep() 后进入阻塞态，yield() 后进入就绪态。
  2. 在 JVM 层面， sleep() 后进入限时等待状态， yield() 后保持运行态。

sleep(long) 方法：

  • 让 Java 线程从 运行态（RUNNABLE），进入 限时等待状态（TIMED_WAITING）。
  • 别的线程可以通过 interrupt() 打断进入 限时等待状态（TIMED_WAITING） 的线程。被打断的线程将会抛出 InterruptedException 异常。异常捕获后，进入 运行态（RUNNABLE），实则进入操作系统层面等待被调度的就绪态。
  • 被唤醒后未必立即执行（唤醒后进入操作系统层面的就绪态，等待被 CPU 调度）

yield() 方法：

  • Java线程状态不变，仍在 运行态（RUNNABLE），实则主动让出 CPU 使用权，在操作系统层面，从运行态进入就绪态。
  • 这是一个 native 方法，具体实现依赖于操作系统的调度器。注意，它让出 CPU 使用权的请求可以被 CPU 调度器忽略。

sleep()和yield()的应用

  • 让线程放弃 CPU 使用权，当没有利用 CPU 做计算时，可以防止 CPU 空转而浪费资源。
  • 可以让线程等待指定时间后继续执行任务。

5. join() 的实现原理

join() 方法主要是为同步等待另一个线程执行结束。使用如下：

public void joinTest(){
    Thread t1 = new Thread(()->{...});
    //在当前线程中，开启一个t1线程
    t1.start();
    //调用t1线程的join方法，当前线程将会阻塞在此，等待t1线程执行结束
    t1.join();
    //t1线程执行结束，才会继续执行下面的代码
    ...
}

join() 主要使用 while(isAlive())进行等待，核心代码如下：

public final synchronized void join(long millis){
    while (isAlive()) {
        wait(0);
    }
}

join() 由 synchronized 修饰。假设 A 线程调用了B线程的 join() 方法，当 A 线程获取到 B 线程的锁后，调用 wait(0) 方法，从而进入无限期等待,即等待状态（WAITING）。

这里可能有人有误解，为什么我调用的是线程 B 的 wait() 方法，但线程 A 进入了无限期等待？

答： 因为这里可以理解为在线程 A 中进行了如下调用：

//这是在线程A中调用了线程B的join方法和wait()方法，虽然调用的是线程B对象的方法，但是上下文环境为线程A，
synchronized(threadB){
    while(threadB.isAlive()){
    	threadB.wait(0);
    }
}

而wait() 方法会让调用者所在线程进入等待状态。在线程 A 中调用了线程 B 的 join() 方法和 wait(0) 方法，虽然调用的是线程 B 对象的方法，但是上下文环境为线程 A ，

只有在线程 B 的 run() 方法中调用的方法，执行方法所在的线程才认为是线程 B

当一个线程执行完时，系统会调用其 exit() 方法，并在其中执行 notifyAll()。所以当线程B执行完毕后，线程A可以被唤醒。

while(isAlive()) 循环判断的意义：一直判断，直到B线程启动。线程对象调用 start() 方法后需要操作系统创建并启动线程，需要时间。

6. interrupt()

interrupt() 的主要任务是通知中断。

  1. 如果线程处于阻塞态，如通过 sleep() , wait()等方法，或者正在I/O阻塞状态，那么 interrupt() 后，该线程会接收到一个异常。
    可以通过 try / catch 中捕获到的异常，判断打断后程序是要终止还是继续运行。
  2. 如果线程是正常运行状态，将会把中断状态设置为 true 。不会影响run()中程序的正常执行，仅知道了"interrupt status == true" 而已。
    可以通过中断标志这个 boolean 值，判断程序是终止还是继续运行。
  3. 如果该线程并不存活，如还未进入运行态，或者已经进入终止态，不会有任何影响。
  4. 通过 LockSupport.part() 阻塞挂起的线程，可以被中断退出阻塞状态，回到就绪态，同时中断标记被 interrupt() 设置为 true 。如果中断标记为真，线程的 LockSupport.park() 方法将会失效。
    想要恢复 park()功能，就要通过 interrupted()来清空打断标记

虽然 LockSupport.park() 和 wait(0) , join() 等方法一样 ，让Java线程进入 等待状态（WAITING），但不同的是，被中断 interrupt() 后，不会抛出异常。示例代码：

public static void main(String[] args) throws InterruptedException {
        //初始化一个名为t1的线程
        Thread t1 = new Thread(()->{
            System.out.println(Thread.currentThread().getName()+": begin run()");
            try{
                LockSupport.park();
            }catch (Exception e){
                System.out.println(e.getMessage());
            }
            System.out.println("t1's status = "+Thread.currentThread().getState());
            System.out.println(Thread.currentThread().getName()+": continue run() after park()");

        },"t1");

        System.out.println(Thread.currentThread().getName()+" :begin t1.start()");
        t1.start();
        System.out.println("t1's status = "+t1.getState());
        System.out.println(Thread.currentThread().getName()+" :begin sleep");
        //这里的等待是为了保证t1进入运行态，且执行了LockSupport.park()方法
        Thread.sleep(5000);
        System.out.println("t1's status = "+t1.getState());
        System.out.println(Thread.currentThread().getName()+" :begin t1.interrupt()");
        t1.interrupt();
    }

上述程序运行结果为：

main :begin t1.start()
t1's status = RUNNABLE
main :begin sleep
t1: begin run()
t1's status = WAITING	//LockSupport.park()方法让Java线程进入到WAITING状态（在操作系统层面为阻塞态）
main :begin t1.interrupt()
t1's status = RUNNABLE //中断后，回到了RUNNABLE状态，且没有抛出异常
t1: continue run() after park() //继续run()后续代码的执行

Process finished with exit code 0

我们可以发现，interrupt() 后， LockSupport.park() 方法并不会抛出异常，而是继续程序执行。

interrupted() vs isInterrupt()

  • interrupted() : 返回打断标记，并清除打断标记（将打断标记设为false)
  • isInterrupted() : 返回打断标记

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

MYSQL分页查询时没有用ORDER BY出现数据重复的问题

MYSQL分页查询时没有用ORDER BY出现数据重复的问题

背景 产品反馈&#xff0c;用户在使用分页列表时&#xff0c;出现数据重复的问题&#xff0c;查看代码后发现对应的分页SQL并没有使用order by进行排序&#xff0c;但是印象中Mysql的InnoDB引擎会默认按照主键id进行排序&#xff0c;本地测试了一下的确出现了部分数据在不同的页…
阅读更多...
单线程事件处理器ControllerEventManager

单线程事件处理器ControllerEventManager

0 前言 单线程事件处理器&#xff0c;Controller端定义的一个组件。该组件内置了一个专属线程&#xff0c;负责处理其他线程发送过来的Controller事件。还定义了一些管理方法&#xff0c;为专属线程输送待处理事件。 0.11.0.0版本前&#xff0c;Controller组件源码复杂。集群…
阅读更多...
【Ajax】XMLHttpRequest和Level2

【Ajax】XMLHttpRequest和Level2

一、XMLHttpRequest什么是XMLHttpRequestXMLHttpRequest&#xff08;简称 xhr&#xff09;是浏览器提供的 Javascript 对象&#xff0c;通过它&#xff0c;可以请求服务器上的数据资源。之前所学的 jQuery 中的 Ajax 函数&#xff0c;就是基于 xhr 对象封装出来的。二、了解xhr…
阅读更多...
java面试

java面试

java面试目录概述需求&#xff1a;设计思路实现思路分析1.代码&#xff1a;参考资料和推荐阅读Survive by day and develop by night. talk for import biz , show your perfect code,full busy&#xff0c;skip hardness,make a better result,wait for change,challenge Surv…
阅读更多...
【数据结构】保姆级队列各接口功能实现

【数据结构】保姆级队列各接口功能实现

目录 &#x1f34a;前言&#x1f34a;&#xff1a; &#x1f95d;一、队列概述&#x1f95d;&#xff1a; 1.队列的概念&#xff1a; 2.队列的结构&#xff1a; &#x1f349;二、队列的各接口功能实现&#x1f349;&#xff1a; 1.初始化队列&#xff1a; 2.入队&#…
阅读更多...
k8s之挂载NFS到POD中

k8s之挂载NFS到POD中

写在前面 在k8s之挂载本地磁盘到POD中 一文中我们看了如何将POD中的数据写到本地磁盘中&#xff0c;这种方式要求POD只能在指定的Node上&#xff0c;一旦POD更换Node&#xff0c;数据依然会丢失&#xff0c;所以本文看下如何通过将数据写到NFS中来解决这个问题。下面我们就开始…
阅读更多...
sklearn数据降维之字典学习

sklearn数据降维之字典学习

文章目录字典学习简介构造函数实战Step1 制作实验数据Step2 小批字典学习Step 3 参数调整字典学习简介 如果把降维理解成压缩的话&#xff0c;那么字典学习的本质是编码&#xff0c;其目的是找到少量的原子&#xff0c;用以描述或构建原始样本。举个一维的例子&#xff0c;以a…
阅读更多...
程序员护眼指南

程序员护眼指南

前言 前言&#xff1a;脱发和近视是当代年轻人的两大痛点&#xff0c;今天来聊聊如何护眼。 文章目录前言一、护眼的核心二、调节睫状肌的方法1. 眨眼2. 望远3. 睡觉4. 促进血液循环5. 吃补剂6. 好的屏幕一、护眼的核心 护眼的核心就是保护睫状肌。 睫状肌是眼内的一种平滑肌…
阅读更多...
一起自学SLAM算法：7.7 典型SLAM算法

一起自学SLAM算法：7.7 典型SLAM算法

连载文章&#xff0c;长期更新&#xff0c;欢迎关注&#xff1a; 针对式&#xff08;7-38&#xff09;所述的在线SLAM系统&#xff0c;以扩展卡尔曼滤波&#xff08;EKF&#xff09;为代表的滤波方法&#xff0c;是求解该状态估计问题最典型的方法&#xff0c;在7.4节中已经详细…
阅读更多...
GY-US42超声波传感器模块介绍

GY-US42超声波传感器模块介绍

GY-US42超声波传感器模块简介GY-US42 是一款低成本高品质测距传感器模块。工作电压 3-5v&#xff0c;功耗小&#xff0c;体积小&#xff0c;安装方便。其工作原理是&#xff0c;探头发射超声波&#xff0c;照射到被测物体后&#xff0c;探头接收返回声波&#xff0c;利用时间差…
阅读更多...
学人工智能电脑主机八大件配置选择指南

学人工智能电脑主机八大件配置选择指南

来源&#xff1a;深度之眼 作者&#xff1a;frank 编辑&#xff1a;学姐 本篇主要是帮助大家构建高性能、高性价比的AI开发的硬件平台。如何不把钱浪费到不必要的硬件上&#xff0c;并合理搭配硬件配置节省预算是本文想要去讨论的问题。如果预算充足&#xff0c;笔者建议购买一…
阅读更多...
【JavaSE专栏1】Java的介绍、特点和历史

【JavaSE专栏1】Java的介绍、特点和历史

作者主页&#xff1a;Designer 小郑 作者简介&#xff1a;Java全栈软件工程师一枚&#xff0c;来自浙江宁波&#xff0c;负责开发管理公司OA项目&#xff0c;专注软件前后端开发&#xff08;Vue、SpringBoot和微信小程序&#xff09;、系统定制、远程技术指导。CSDN学院、蓝桥云…
阅读更多...
Python ·保险理赔分析：数据分析

Python ·保险理赔分析：数据分析

介绍 提示&#xff1a;这里可以添加系列文章的所有文章的目录&#xff0c;目录需要自己手动添加 在本笔记本中&#xff0c;我们将仔细研究保险索赔&#xff0c;并弄清一些有关血压、BMI、糖尿病、吸烟、年龄和性别等条件如何影响索赔价值的事实。 我们将使用散点图、饼图、直…
阅读更多...
IDEA必装插件-Gyro

IDEA必装插件-Gyro

前言用SpringBootTest运行单测的时候&#xff0c;是不是每运行都需要重新启动Spring容器&#xff1f;大型应用启动一次会浪费大量的时间&#xff0c;导致效率比较低。Gyro插件可以解决你的问题。Gyro介绍它是一个IDEA插件&#xff0c;安装之后&#xff0c;用Gyro Debug运行你的…
阅读更多...
一起自学SLAM算法：7.4 基于贝叶斯网络的状态估计

一起自学SLAM算法：7.4 基于贝叶斯网络的状态估计

连载文章&#xff0c;长期更新&#xff0c;欢迎关注&#xff1a; 在7.2.4节中&#xff0c;讨论了表示机器人观测与运动之间依赖关系的概率图模型&#xff0c;主要是贝叶斯网络&#xff08;实际应用在机器人中的是动态贝叶斯网络&#xff09;和马尔可夫网络&#xff08;实际应用…
阅读更多...
fpga实操训练（lcd字符显示）

fpga实操训练（lcd字符显示）

【 声明：版权所有，欢迎转载，请勿用于商业用途。 联系信箱：feixiaoxing @163.com】 用fpga编写屏幕显示，和c语言编写有很大的不同。用c语言开发，很大程度上是遵循soc ip提供的规范进行编写。而用fpga开发的话，则需要考虑不同信号的时序关系。但是，用fpga开发也有…
阅读更多...
c++ 优先级队列priority_queue的使用

c++ 优先级队列priority_queue的使用

c priority_queue是对其他容器元素顺序的调整包装; 堆的原理 1.定义 priority_queue<Type, Container, Functional> q; 其中&#xff0c;Type是数据类型&#xff0c;Container是低层容器&#xff0c;如vector, stack, deque等. Functional是比较函数&#xff1b;默认可…
阅读更多...
day25-类加载器反射

day25-类加载器反射

1.类加载器 1.1类加载器【理解】 作用 负责将.class文件&#xff08;存储的物理文件&#xff09;加载在到内存中 1.2类加载的过程【理解】 类加载时机 创建类的实例&#xff08;对象&#xff09;调用类的类方法访问类或者接口的类变量&#xff0c;或者为该类变量赋值使用反…
阅读更多...
NodeJS 之 HTTP 模块（实现一个基本的 HTTP 服务器）

NodeJS 之 HTTP 模块（实现一个基本的 HTTP 服务器）

NodeJS 之 HTTP 模块&#xff08;实现一个基本的 HTTP 服务器&#xff09;参考描述HTTP 模块搭建 HTTP 服务器http.createServer()监听检测服务器端口是否被占用终端Error Code超时处理处理客户端的请求request 事件http.IncomingMessagehttp.ServerResponse中文乱码问题问题解…
阅读更多...
Java EE之线程编(进阶版)

Java EE之线程编(进阶版)

这些锁策略能适用于很多中语言&#xff0c;博主是学Java的&#xff0c;所以下面的代码会用Java去写&#xff0c;请大家见谅&#xff0c;但是处理的方法是大差不差的。 一、常见锁和锁策略&#xff1a; (一)、乐观锁和悲观锁 1、何为乐观锁和悲观锁呢&#xff1f; 答&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023