架构视界
主页
企业架构
  • 方案总览
  • 业财一体
  • 企业中台
  • 组织与绩效
  • 流程治理
数据收集与分析
  • 转型总览
  • 信息化阶段
  • 数字化解决方案
  • 智数化解决方案
  • 智能化解决方案
  • 产品设计
  • 项目管理
全栈软件工程
AI 原生软件工程
方法论
博客
  • 资源导航
  • 效率工具
  • 展示专区
主页
企业架构
  • 方案总览
  • 业财一体
  • 企业中台
  • 组织与绩效
  • 流程治理
数据收集与分析
  • 转型总览
  • 信息化阶段
  • 数字化解决方案
  • 智数化解决方案
  • 智能化解决方案
  • 产品设计
  • 项目管理
全栈软件工程
AI 原生软件工程
方法论
博客
  • 资源导航
  • 效率工具
  • 展示专区
  • 标签索引
  • 2024年

    • 勇闯大A:美债与美元周期
    • 勇闯大A:交易纪律与自我管理
    • 勇闯大A:交易系统分层
    • 勇闯大A:买卖点与止损规则
    • 勇闯大A:债券与资金流向
    • 勇闯大A:微观、宏观与周期
    • Mac 开发环境:新机配置清单
    • 勇闯大A:内外盘与换手率
    • 会计管理:财报阅读与管理报表
    • 会计基础:记账原理与分录
    • 财务入门:财务体系全景
  • 2023年

    • 境外投资:泰国 BOI 申请实务
  • 2022年

    • 企业架构:故障管理与分级响应
    • 企业架构:技术债务的识别、度量与偿还
  • 2021年

    • Python 数据分析:员工分布可视化
    • Python 数据分析:IP 访问折线图
    • Python 数据分析:IP 词云图
    • Redis:RediSearch 全文检索
    • Rust 基础:第一个 CLI 程序
    • Rust 基础:所有权机制
    • Rust 基础:函数与控制流
    • Rust 基础:变量与数据类型
    • Rust 基础:入门与开发环境
    • 企业架构:分布式系统设计
    • 企业架构:编程式权限设计
    • JVM 调优:启动参数与 GC 日志
    • MyBatis 批量插入:三种写法对比
    • 测试:Spring Boot 分层 Mock
    • Redis:布隆过滤器判断元素存在
    • Jenkins:安装配置与应用部署
    • WebClient:非阻塞 HTTP 客户端
    • Drone:Docker 部署轻量 CI
    • Spring AOP:操作审计日志落库
    • Redisson:分布式锁与 RedLock
    • MyBatis 拦截器:雪花算法主键
    • Netty:线程模型与网络编程
    • Redis:SCAN 游标遍历大键空间
    • Jenkins:单机部署与升级脚本
    • Mac:Neo4j 与 Jupyter 安装
    • JavaFX:OpenJDK 11 环境配置
    • Mac:用 jenv 管理 JDK 版本
    • Redis:有序集合实现延时队列
    • Spring Boot 日志:MDC 串联链路
    • 定时任务:Spring 调度与 Cron
    • GoAccess:Nginx 日志分析
    • MyBatis 拦截器:慢 SQL 分析
    • Lucene:倒排索引与中文分词
    • 分布式锁:三种实现方案对比
    • 学习技巧:减少学习排斥心理
    • 动态数据源:多租户数据路由
    • Compose:Spring Boot 三件套
    • Java 阻塞队列:源码与用法
    • Redis:Docker Compose 哨兵
    • Redis:Docker Compose 主从
    • 网络通信:TCP/IP 与 HTTP 基础
  • 2020年

    • 延时队列:DelayQueue 与 Redis 实现
    • MySQL 基础:员工库导入实践
    • 雪花算法:分布式 ID 生成
    • Redis:地理位置查询
    • 抓包:Wireshark 与 Tcpdump
    • SPI:JDK 与 Spring 扩展机制
    • ZooKeeper:概念与集群搭建
    • Spring Boot:集成 JMH 基准测试
    • Wireshark:抓包工具入门
    • Compose:Redis 与 MySQL
    • CentOS 7:Docker 安装部署
    • Netty:源码阅读环境搭建
    • MySQL 基础:SQL 常见用法
    • CentOS 7:Selenium 运行环境
    • Nginx:HTTPS 证书配置
    • JMH:基准测试与 Spring Boot 集成
    • Spring Boot:指定 Tomcat 版本
    • Eureka:实例上下线告警
    • 钉钉告警:应用异常与实例上下线
    • JVM:内存布局、类加载与调优
    • Git:rebase 合并多次提交
    • CentOS 7:OpenResty 部署
  • 2019年

    • Redis CLI:macOS 安装与使用
    • Nginx:访问日志格式
    • 工程规范:可维护代码的写法
    • IntelliJ IDEA:常用插件
    • SkyWalking:源码阅读环境搭建
    • Spring Boot:Redis 超时配置
    • gRPC:ProtoBuf 定义与代码生成
    • Arthas:Java 线上问题诊断
    • Redis:缓存穿透与击穿防护
    • Docker 部署:Elasticsearch
    • Docker 部署:MySQL 5.7 单机
    • Spring Redis:字符串命令封装
    • Docker 部署:ZooKeeper 运行
    • Docker 部署:Redis 单机运行
    • Dubbo:Spring Boot 微服务集成
    • CentOS 7:CMake 源码编译安装
    • 性能度量:吞吐量与 QPS 指标
    • Java 递归:从笔试题到经典问题
    • CentOS 7:ELK 日志平台部署
    • CentOS 7:SonarQube 部署
    • Selenium:Chrome 浏览器自动化
    • JJWT:令牌生成与解析测试
    • Spring 源码:阅读环境搭建
    • JUnit 4:注解、断言与参数化
    • JWT:令牌结构与签名机制
    • FastDFS:架构与文件存取机制
    • XPath:XML 文档节点定位
    • Redis 基础:锁、队列与事务
    • Redis 基础:数据类型与命令
    • MyBatis:Slf4j 日志接入
    • MyBatis:H2 单元测试与 SQL 日志
    • 源码阅读:开源项目环境搭建
    • Git 配置:命令清单与作用域
    • Java 核心:面向对象与基础类型
    • Java 核心:关键字、异常与反射
    • Java 核心:多线程基础
    • Java 核心:同步关键字与线程池
    • Java 核心:锁与并发工具
    • Java 核心:语言基础与并发
    • Dubbo:远程调用与服务治理
    • Java 集合:框架总览与实现对比
    • Maven:生命周期与常用命令
    • MyBatis:执行流程与插件机制
    • Spring:IoC 容器与依赖注入
    • Spring:AOP 与自动装配
    • Spring:事务与启动流程
    • Spring:IoC、AOP 与事务
    • Spring MVC:请求分发与注解
    • MySQL:架构与索引
    • MySQL:事务、锁与 MVCC
    • MySQL:日志与 SQL 优化
    • MySQL:架构、事务与优化
    • Redis 基础:持久化与线程模型
  • 2018年

    • Java HashMap:扩容机制与哈希冲突
    • Java 集合:HashSet 去重原理
    • Java 基础:交换两个变量的值
    • Spring MVC:零 web.xml 改造
    • Mac 开发环境:新机配置清单
    • Log4j:日志分级与按业务拆分
    • Modbus:工业通信协议与 RTU 帧
    • MySQL 基础:子查询与连接查询
    • MySQL 基础:库与表操作
    • MySQL 基础:表操作与查询
    • MySQL 基础:约束、引擎与数据类型
    • MySQL 基础:库表、约束与类型
    • Java 集合:Vector 与 Stack
    • Java 集合:Vector 与 Stack
    • RabbitMQ:CentOS 7 单机部署
    • Redis:CentOS 7 单机部署
    • MongoDB:CentOS 7 单机部署
    • Linux:常用系统与运维命令
    • 注册中心:Eureka 与 ZooKeeper
    • MySQL:CentOS 7 单机部署
    • Git 分支:主分支与临时分支
    • CentOS 7:Java 开发环境部署
    • Java 集合:LinkedList 双向链表
    • Java 集合:ArrayList 动态数组
    • Spring AOP:注解方式实现切面
← 返回博客

Java 核心:多线程基础

2019年1月1日 #后端开发 #Java

系列文章:Java 核心:语言基础与并发 的第 3 篇。

Java多线程

Java中的主线程

Java为多线程编程提供内置支持。多线程程序包含两个或多个可以并发运行的部分。这样的程序的每个部分称为线程,每个线程定义一个单独的执行路径。当Java程序启动时,一个线程立即开始运行。这通常被称为我们程序的主线程,因为它是我们程序开始时执行的那个。

  • 它是生产启动其它子线程的线程。
  • 它负责程序结束时候的收尾工作。

上面简单画图出一个主线程和子线程以及后台线程的关系。

在主线程中,这可以通过调用Thread类中的*currentThread()*方法来完成。此方法返回对其调用的线程的引用。主线程的默认优先级为5,对于所有剩余的用户线程,优先级将从父级继承到子级。同时虚拟机会启动其它的线程,比如垃圾回收器GC。

package cn.z201.java.test.thread;

/**
 * @author z201.coding@gmail.com
 **/
public class ChildThread extends Thread{

    public ChildThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        for (int i = 0; i < 3 ; i++) {
            System.out.println(Thread.currentThread().getName() + ":  " + i);
        }
    }
}

package cn.z201.java.test.thread;

/**
 * @author z201.coding@gmail.com
 **/
public class MasterThread {

    public static void main(String[] args) {

        Thread master = Thread.currentThread();
        // getting name of Main thread
        System.out.println("Current thread: " + master.getName());

        // changing the name of Main thread
        master.setName("Master");
        System.out.println("After name change: " + master.getName());

        // getting priority of Main thread
        System.out.println("Main thread priority: "+ master.getPriority());

        // setting priority of Main thread to MAX(10)
        master.setPriority(Thread.MAX_PRIORITY);

        System.out.println("Main thread new priority: "+ master.getPriority());

        for (int i = 0; i < 3; i++) {
            System.out.println("MasterThread " + i);
        }

        ChildThread childThread1 = new ChildThread("childThread1");
        // getting priority of child thread
        // which will be inherited from Main thread
        // as it is created by Main thread
        System.out.println("Child1 thread priority: "+ childThread1.getPriority());
        // setting priority of Main thread to MIN(1)
        childThread1.setPriority(Thread.MIN_PRIORITY);
        System.out.println("Child1 thread new priority: "+ childThread1.getPriority());

        ChildThread childThread2 = new ChildThread("childThread2");
        System.out.println("Child2 thread priority: "+ childThread2.getPriority());
        childThread2.setPriority(Thread.NORM_PRIORITY);
        System.out.println("Child2 thread new priority: "+ childThread2.getPriority());
        // starting child thread
        childThread1.start();
        childThread2.start();

    }
}
   
输出
Current thread: main
After name change: Master
Main thread priority: 5
Main thread new priority: 10
MasterThread 0
MasterThread 1
MasterThread 2
Child1 thread priority: 10
Child1 thread new priority: 1
Child2 thread priority: 10
Child2 thread new priority: 5
childThread1:  0
childThread1:  1
childThread1:  2
childThread2:  0
childThread2:  1
childThread2:  2

主线程默认优先级是5经过修改为10,启动的子线程就继承了主线程的级别。

什么是进程

  • 进程是程序运行和资源分配的基本单位,一个程序至少一个进程,一个进程至少一个线程。

  • 多个进程的*内部数据和状态是完全独立的*,而多个线程是共享一个内存空间和一组系统资源,有可能互相影响。


什么是线程

  • 线程是程序内部的控制流,只能使用分配给线程 的资源和环境。
  • 线程本身的数据通常只有寄存器数据,以及一个程序执行时使用的堆栈,所以线程的切换比进程切换负担要小。
  • 线程是进程的一个实体,是cpu调度和分派的基本单位,是比程序更小能独立运行的基本单位。

多线程编程的目的

充分的利用 CPU 和 I/O 的利用率

  • 多线程编程的目的,就是 最大限度地利用CPU资源,当某一线程的处理不需要占用CPC而和I/O等资源打交道时,让需要占用CPU资源的其他线程有机会获得CPU资源,从根本上,这就是多线程编程的最终目的。
  • 线程(Thread)也是程序的最小单元,它依托进程而存在。
  • 多个线程可以共享一块内存空间和一组系统资源因此线程之前的切换更加节省资源、更加轻量化,也因此被称为轻量级的进程。

多线程概念介绍

  • 一个进程可以包含多个线程。
  • 一个程序实现多个代码同时交替运行就需要产生多个线程。
  • CPU随机的抽出时间,让我们的程序一会做这件事情,一会做另外一件事情。
  • 同期其他大多数编程语言不同,Java内置支持多线程编程(multithreaded progranmming)。多线程程序包包含两个或两条以上并发运作的部分,吧程序中每个这种的部分都叫做一个线程(thread),每个线程都独立的执行路经,因此多线程是多任务处理的一种特殊形式。
  • 多任务处理被所有的现代操作系统所支持。然后,多任务处理有两种截然不同的类型,基于进程和基于线程。
    • 基于进程
      • 基于进程的多任务处理是更熟悉的形式,进程(process)本质上是一个执行的程序。因此基于进程的多线程任务处理的特点是允许你的计算机同时运行两个或更多的程序。
    • 基于线程
      • 基于线程(thread-based)的多任务处理环境中,线程是最小的执行单位。这意味着一个程序可以执行两个或则多个任务的功能。
    • 多线程程序比多进程程序需要更少的管理资源。
      • 进程是重量级的任务,需要分配给他们的独立空间地址。进程之间通信是昂贵和受限的。进程之间的转换也是很需要花费的。另一方面,线程是轻量级的选手,它们共享相同的地址空间并且共享同一进程,线程之间通信是轻量级的,线程的转换也是轻量级的。
    • 线程的实现
      • 1.两种方法均需要执行线程start方法作为线程分配必须的系统资源、调度线程运行并执行线程的run方法。
      • 2.在具体应用中,采用哪种方法来构造线程体要试情况而定。通常,当一个线程继承了另一个类,应该应该使用第二种方法,即使实现runnable接口。
      • 3.线程的消亡不能通过调用 Thread.stop 方法,而是让线程自然消亡。

线程的生命周期

一个线程的消亡过程。

  • 新建(New)

    • 创建后尚未启动。
  • 可运行(Runnable)

    • 可能正在运行,也可能正在等待 CPU 时间片。
    • 包含了操作系统线程状态中的 运行(Running ) 和 就绪(Ready)。
  • 无限期等待(Waiting)

    • 等待其它线程显式地唤醒,否则不会被分配 CPU 时间片。

      进入方法退出方法
      没有设置 Timeout 参数的 Object.wait() 方法Object.notify() / Object.notifyAll()
      没有设置 Timeout 参数的 Thread.join() 方法被调用的线程执行完毕
      LockSupport.park() 方法-
  • 限期等待(Timed Waiting)

    • 无需等待其它线程显式地唤醒,在一定时间之后会被系统自动唤醒。

    • 调用 Thread.sleep() 方法使线程进入限期等待状态时,常常用 “使一个线程睡眠” 进行描述。

    • 调用 Object.wait() 方法使线程进入限期等待或者无限期等待时,常常用 “挂起一个线程” 进行描述。

    • 睡眠和挂起是用来描述行为,而阻塞和等待用来描述状态。

    • 阻塞和等待的区别在于,阻塞是被动的,它是在等待获取一个排它锁。而等待是主动的,通过调用 Thread.sleep() 和 Object.wait() 等方法进入。

      进入方法退出方法
      Thread.sleep() 方法时间结束
      设置了 Timeout 参数的 Object.wait() 方法时间结束 / Object.notify() / Object.notifyAll()
      设置了 Timeout 参数的 Thread.join() 方法时间结束 / 被调用的线程执行完毕
      LockSupport.parkNanos() 方法-
      LockSupport.parkUntil() 方法-
  • 阻塞(Blocking)

    • 这个状态下,是在多个线程有同步操作的场景,比如正在等待另一个线程的 synchronized 块的执行释放,或者可重入的 synchronized 块里别人调用 wait() 方法,也就是线程在等待进入临界区。
    • 阻塞可以分为:等待阻塞,同步阻塞,其他阻塞
  • 死亡(Terminated)

    • 线程因为 run 方法正常退出而自然死亡。
    • 因为一个没有捕获的异常终止了 run 方法而意外死亡。

线程的状态

线程的基本方法

  • wait线程等待

    • 调用该方法的线程进入 WAITING 状态,只有等待另外线程的通知或被中断才会返回,需要注意的是调用 wait()方法后,会释放对象的锁。因此,wait 方法一般用在同步方法或同步代码块中。
  • sleep线程睡眠

    • sleep 导致当前线程休眠,与 wait 方法不同的是 sleep 不会释放当前占有的锁,sleep(long)会导致线程进入 TIMED-WATING 状态,而 wait()方法会导致当前线程进入 WATING 状态。
  • yield线程让步

    • yield 会使当前线程让出 CPU 执行时间片,与其他线程一起重新竞争 CPU 时间片。一般情况下,优先级高的线程有更大的可能性成功竞争得到 CPU 时间片,但这又不是绝对的,有的操作系统对线程优先级并不敏感。
  • interrupt线程中断

    • 中断一个线程,其本意是给这个线程一个通知信号,会影响这个线程内部的一个中断标识位。这个线程本身并不会因此而改变状态(如阻塞,终止等)。

      • 调用 interrupt()方法并不会中断一个正在运行的线程。也就是说处于 Running 状态的线程并不会因为被中断而被终止,仅仅改变了内部维护的中断标识位而已。

      • 若调用 sleep()而使线程处于 TIMED-WATING 状态,这时调用 interrupt()方法,会抛出InterruptedException,从而使线程提前结束 TIMED-WATING 状态。

        许多声明抛出 InterruptedException 的方法(如 Thread.sleep(long mills 方法)),抛出异常前,都会清除中断标识位,所以抛出异常后,调用 isInterrupted()方法将会返回 false。

      • 中断状态是线程固有的一个标识位,可以通过此标识位安全的终止线程。比如,你想终止一个线程 thread 的时候,可以调用 thread.interrupt()方法,在线程的 run 方法内部可以根据 thread.isInterrupted()的值来优雅的终止线程。

  • join等待其它线程终止

    • join() 方法,等待其他线程终止,在当前线程中调用一个线程的 join() 方法,则当前线程转为阻塞状态,回到另一个线程结束,当前线程再由阻塞状态变为就绪状态,等待 cpu 的宠幸。
    • 很多情况下,主线程生成并启动了子线程,需要用到子线程返回的结果,也就是需要主线程需要在子线程结束后再结束,这时候就要用到 join() 方法。
  • notify线程唤醒

    • Object 类中的 notify() 方法,唤醒在此对象监视器上等待的单个线程,如果所有线程都在此对象上等待,则会选择唤醒其中一个线程,选择是任意的,并在对实现做出决定时发生,线程通过调用其中一个 wait() 方法,在对象的监视器上等待,直到当前的线程放弃此对象上的锁定,才能继续执行被唤醒的线程,被唤醒的线程将以常规方式与在该对象上主动同步的其他所有线程进行竞争。类似的方法还有 notifyAll() ,唤醒再次监视器上等待的所有线程。
  • 其它方法

    • isAlive(): 判断一个线程是否存活。
    • activeCount(): 程序中活跃的线程数。
    • enumerate(): 枚举程序中的线程。
    • currentThread(): 得到当前线程。
    • isDaemon(): 一个线程是否为守护线程。
    • setDaemon(): 设置一个线程为守护线程。(用户线程和守护线程的区别在于,是否等待主线程依赖于主线程结束而结束)
    • setName(): 为线程设置一个名称。
    • setPriority(): 设置一个线程的优先级。
    • getPriority()::获得一个线程的优先级。

线程优先级

  • 设置优先级是为了在多线程环境中便于系统对线程调度,优先级高的线程将优先执行。

    • 一个线程的优先级遵从以下原则。
      • 线程创建时,子继承父的优先级。
      • 线程创建后,可用过调用setPriority()方法改变优先级。
      • 线程的优先级是1-10之间的正整数。
        • 1 - MIN_PRIORITY
        • 10 - MAX_PRIORITY
        • 5 - NORM_PRIORITY
  • 线程的优先级策略

    • 线程调度器选择优先级最高的线程运行.但是,如果发生以下情况,就会终止线程的运行.
      • 线程体中调用了yieid()方法,让出了对CPU的占用权。
      • 线程体中调用sleep()方法,使线程进入了睡眠状态。
      • 线程由I/O操作而受阻塞。
      • 另一个更高优先级的线程出现。
      • 在支持时间片段系统中,该线程的时间片用完。

上下文切换

  • 是指某一时间点 CPU 寄存器和程序计数器的内容。

    • 寄存器
      • 是 CPU 内部的数量较少但是速度很快的内存(与之对应的是 CPU 外部相对较慢的 RAM 主内存)。寄存器通过对常用值(通常是运算的中间值)的快速访问来提高计算机程序运行的速度。
    • 程序计数器
      • 是一个专用的寄存器,用于表明指令序列中 CPU 正在执行的位置,存的值为正在执行的指令的位置或者下一个将要被执行的指令的位置,具体依赖于特定的系统。
    • 上下文切换的活动
    1. 挂起一个进程,将这个进程在 CPU 中的状态(上下文)存储于内存中的某处。
    2. 在内存中检索下一个进程的上下文并将其在 CPU 的寄存器中恢复。
    3. 跳转到程序计数器所指向的位置(即跳转到进程被中断时的代码行),以恢复该进程在程序中。
    • 引起线程上下文切换的原因
    1. 当前执行任务的时间片用完之后,系统 CPU 正常调度下一个任务。
    2. 当前执行任务碰到 IO 阻塞,调度器将此任务挂起,继续下一任务。
    3. 多个任务抢占锁资源,当前任务没有抢到锁资源,被调度器挂起,继续下一任务。
    4. 用户代码挂起当前任务,让出 CPU 时间。
    5. 硬件中断。

线程的同步

  • 在多线程环境中,可能会出现两个甚至多个线程试图同时访问一个有限的资源。必须对这种潜在的资源冲突进行预防。
    • 解决方案:在线程使用一个资源时为其加锁即可。访问资源的第一个线程为其上锁以后,其他线程比便不能在使用那个资源。除非被解锁。
  • 在线程环境中,关于成员变量与局部变量;如果一个变量是成员变量,那么多个线程对同一个对象的成员变量进行操作时候,他们对该成员变量是彼此影响到(也就是说一个线程对成员变量的改变会影响另一个到另一线程)。
  • 不能依靠线程优先级来决定线程的执行。
  • 同步到实现方式
    • synchronized 关键字;当synchronized关键字修饰一个方法的时候,该方法叫做同步方法。
    • Java中方锁。
      • java中每个对象都有一个锁(lock)或者叫监视器(monitor),当访问一个对象synchronized方法时,表示将该对象上锁,此时其他任何线程在去访问该synchronized方法了,直到之前那个线程执行方法完毕后(或者抛出异常),那么该对象的锁释放掉。其他线程才有可能再去访问synchronized方法。
      • 如果一个对象中有多个synchronized方法,某一时刻某个线程进入了该对象中的synchronized方法,那么在该方法没有执行完成之前或者抛出异常之前,其他线程是无法访问该对象的任何synchronized方法。
      • 被synchronized保护的变量应该是private修饰的。
      • 如果某个synchronized方法被static修饰的,那么当线程访问该方法时候,它锁定并不是对象(实例),而是synchronized方法所以在对象所对应的Class对象,因为Java中无论一个类有多少个对象,这些对象都会对应唯一一个Class对象,因此当线程分别访问一个类的两个对象的两个static synchronized方法时,他们的执行顺序是顺序的,也就是说一个线程先执行方法,执行完毕后另一个线程才开始执行。
      • synchronized方法是一个粗粒度的控制,某一个时刻只能有一个方法执行synchronized方法;sysnchronized块则是一种细粒度的控制方;只会将代码块同步。位于方法内、synchronized块之外的代码是可以被多个线程同时访问的。

线程如何工作的

  • 线程的状态在枚举的方式被定义在 Thread 的源码中,它总共包含以下 6 个状态:

    • NEW,新建状态,线程被创建出来,但尚未启动时的线程状态;
    • RUNNABLE,就绪状态,表示可以运行的线程状态,它可能正在运行,或者是在排队等待操作系统给它分配 CPU 资源;
    • BLOCKED,阻塞等待锁的线程状态,表示处于阻塞状态的线程正在等待监视器锁,比如等待执行 synchronized 代码块或者使用 synchronized 标记的方法;
    • WAITING,等待状态,一个处于等待状态的线程正在等待另一个线程执行某个特定的动作,比如,一个线程调用了 Object.wait() 方法,那它就在等待另一个线程调用 Object.notify() 或 Object.notifyAll() 方法;
    • TIMED_WAITING,计时等待状态,和等待状态(WAITING)类似,它只是多了超时时间,比如调用了有超时时间设置的方法 Object.wait(long timeout) 和 Thread.join(long timeout) 等这些方法时,它才会进入此状态;
    • TERMINATED,终止状态,表示线程已经执行完成。

线程的执行流程

  • 首先先要创建线程并指定线程需要执行的业务方法,然后再调用线程的 start() 方法,此时线程就从 NEW(新建)状态变成了 RUNNABLE(就绪)状态,此时线程会判断要执行的方法中有没有 synchronized 同步代码块,如果有并且其他线程也在使用此锁,那么线程就会变为 BLOCKED(阻塞等待)状态,当其他线程使用完此锁之后,线程会继续执行剩余的方法。当遇到 Object.wait() 或 Thread.join() 方法时,线程会变为 WAITING(等待状态)状态,如果是带了超时时间的等待方法,那么线程会进入 TIMED_WAITING(计时等待)状态,当有其他线程执行了 notify() 或 notifyAll() 方法之后,线程被唤醒继续执行剩余的业务方法,直到方法执行完成为止,此时整个线程的流程就执行完了

Java实现多线程的方式

有三种使用线程的方法:

  • 实现 Runnable 接口;
  • 实现 Callable 接口;
  • 继承 Thread 类。

实现 Runnable 和 Callable 接口的类只能当做一个可以在线程中运行的任务,不是真正意义上的线程,因此最后还需要通过 Thread 来调用。可以说任务是通过线程驱动从而执行的。

实现 Runnable 接口

需要实现 run() 方法。

通过 Thread 调用 start() 方法来启动线程。

public class MyRunnable implements Runnable {
    public void run() {
        // ...
    }
}
public static void main(String[] args) {
    MyRunnable instance = new MyRunnable();
    Thread thread = new Thread(instance);
    thread.start();
}

实现 Callable 接口

与 Runnable 相比,Callable 可以有返回值,返回值通过 FutureTask 进行封装。

public class MyCallable implements Callable<Integer> {
    public Integer call() {
        return 123;
    }
}
public static void main(String[] args) throws ExecutionException, InterruptedException {
    MyCallable mc = new MyCallable();
    FutureTask<Integer> ft = new FutureTask<>(mc);
    Thread thread = new Thread(ft);
    thread.start();
    System.out.println(ft.get());
}

继承 Thread 类

同样也是需要实现 run() 方法,因为 Thread 类也实现了 Runable 接口。

public class MyThread extends Thread {
    public void run() {
        // ...
    }
}
public static void main(String[] args) {
    MyThread mt = new MyThread();
    mt.start();
}

Runnable VS Thread

实现接口会更好一些,因为:

  • Java 不支持多重继承,因此继承了 Thread 类就无法继承其它类,但是可以实现多个接口;
  • 类可能只要求可执行就行,继承整个 Thread 类开销过大。

三种方式的区别

  • 实现 Runnable 接口可以避免 Java 单继承特性而带来的局限;增强程序的健壮性,代码能够被多个线程共享,代码与数据是独立的;适合多个相同程序代码的线程区处理同一资源的情况。
  • 继承 Thread 类和实现 Runnable 方法启动线程都是使用 start() 方法,然后 JVM 虚拟机将此线程放到就绪队列中,如果有处理机可用,则执行 run() 方法。
  • 实现 Callable 接口要实现 call() 方法,并且线程执行完毕后会有返回值。其他的两种都是重写 run() 方法,没有返回值。

BLOCKED(阻塞等待)和 WAITING(等待)有什么区别

  • 虽然 BLOCKED 和 WAITING 都有等待的含义,但二者有着本质的区别,首先它们状态形成的调用方法不同,其次 BLOCKED 可以理解为当前线程还处于活跃状态,只是在阻塞等待其他线程使用完某个锁资源;而 WAITING 则是因为自身调用了 Object.wait() 或着是 Thread.join() 又或者是 LockSupport.park() 而进入等待状态,只能等待其他线程执行某个特定的动作才能被继续唤醒,比如当线程因为调用了 Object.wait() 而进入 WAITING 状态之后,则需要等待另一个线程执行 Object.notify() 或 Object.notifyAll() 才能被唤醒。

start() 方法和 run() 方法有什么区别

Thread 源码来看,start() 方法属于 Thread 自身的方法,并且使用了 synchronized 来保证线程安全,源码如下

public synchronized void start() {
    // 状态验证,不等于 NEW 的状态会抛出异常
    if (threadStatus != 0)
        throw new IllegalThreadStateException();
    // 通知线程组,此线程即将启动

    group.add(this);
    boolean started = false;
    try {
        start0();
        started = true;
    } finally {
        try {
            if (!started) {
                group.threadStartFailed(this);
            }
        } catch (Throwable ignore) {
            // 不处理任何异常,如果 start0 抛出异常,则它将被传递到调用堆栈上
        }
    }
}

run() 方法为 Runnable 的抽象方法,必须由调用类重写此方法,重写的 run() 方法其实就是此线程要执行的业务方法,源码如下:

public class Thread implements Runnable {
 // 忽略其他方法......
  private Runnable target;
  @Override
  public void run() {
      if (target != null) {
          target.run();
      }
  }
}
@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

从执行的效果来说,start() 方法可以开启多线程,让线程从 NEW 状态转换成 RUNNABLE 状态,而 run() 方法只是一个普通的方法。

其次,它们可调用的次数不同,start() 方法不能被多次调用,否则会抛出 java.lang.IllegalStateException;而 run() 方法可以进行多次调用,因为它只是一个普通的方法而已。

线程的优先级有什么用?该如何设置

在 Thread 源码中和线程优先级相关的属性有 3 个:

// 线程可以拥有的最小优先级
public final static int MIN_PRIORITY = 1;

// 线程默认优先级
public final static int NORM_PRIORITY = 5;

// 线程可以拥有的最大优先级
public final static int MAX_PRIORITY = 10

线程的优先级可以理解为线程抢占 CPU 时间片的概率,优先级越高的线程优先执行的概率就越大,但并不能保证优先级高的线程一定先执行。

在程序中我们可以通过 Thread.setPriority() 来设置优先级,setPriority() 源码如下:

public final void setPriority(int newPriority) {
    ThreadGroup g;
    checkAccess();
    // 先验证优先级的合理性
    if (newPriority > MAX_PRIORITY || newPriority < MIN_PRIORITY) {
        throw new IllegalArgumentException();
    }
    if((g = getThreadGroup()) != null) {
        // 优先级如果超过线程组的最高优先级,则把优先级设置为线程组的最高优先级
        if (newPriority > g.getMaxPriority()) {
            newPriority = g.getMaxPriority();
        }
        setPriority0(priority = newPriority);
    }
}

sleep() 和wait()的区别

  • sleep是Thread的成员方法,睡眠时保持对象锁,仍然占有该锁。

    • sleep()使当前线程进入停滞状态(阻塞当前线程),让出CUP的使用、目的是不让当前线程独自霸占该进程所获的CPU资源,以留一定时间给其他线程执行的机会;sleep()是Thread类的Static(静态)的方法;因此他不能改变对象的机锁,所以当在一个Synchronized块中调用Sleep()方法是,线程虽然休眠了,但是对象的机锁并木有被释放,其他线程无法访问这个对象(即使睡着也持有对象锁)。在sleep()休眠时间期满后,该线程不一定会立即执行,这是因为其它线程可能正在运行而且没有被调度为放弃执行,除非此线程具有更高的优先级。
  • wait是Object的成员方法睡眠时,释放对象锁。

    • wait()方法是Object类里的方法;当一个线程执行到wait()方法时,它就进入到一个和该对象相关的等待池中,同时失去(释放)了对象的机锁(暂时失去机锁,wait(long timeout)超时时间到后还需要返还对象锁);其他线程可以访问;wait()使用notify或者notifyAlll或者指定睡眠时间来唤醒当前等待池中的线程。wiat()必须放在synchronized block中,否则会在program runtime时扔出”java.lang.IllegalMonitorStateException“异常。
  • 两者最主要的区别在于:sleep ⽅法没有释放锁,⽽ wait ⽅法释放了锁 。

  • wait 通常被⽤于线程间交互/通信,sleep 通常被⽤于暂停执⾏。

  • wait() ⽅法被调⽤后,线程不会⾃动苏醒,需要别的线程调⽤同⼀个对象上的 notify() 或者notifyAll() ⽅法。sleep() ⽅法执⾏完成后,线程会⾃动苏醒。或者可以使⽤ wait(longtimeout)超时后线程会⾃动苏醒。

  • wait只能在synchronize代码块中,sleep不需要。

为什么我们调⽤ start() ⽅法时会执⾏ run() ⽅法,为什么我们不能直接调⽤run() ⽅法

  • new ⼀个 Thread,线程进⼊了新建状态;调⽤ start() ⽅法,会启动⼀个线程并使线程进⼊了就绪状态,当分配到时间⽚后就可以开始运⾏了。 start() 会执⾏线程的相应准备⼯作,然后⾃动执⾏run() ⽅法的内容,这是真正的多线程⼯作。 ⽽直接执⾏ run() ⽅法,会把 run ⽅法当成⼀个 main线程下的普通⽅法去执⾏,并不会在某个线程中执⾏它,所以这并不是多线程⼯作。
  • 总结: 调⽤ start ⽅法⽅可启动线程并使线程进⼊就绪状态,⽽ run ⽅法只是 thread 的⼀个普通⽅法调⽤,还是在主线程⾥执⾏。

notify与notifyAll的区别

尽量使用notifyAll。

  • 调用 notify() 方法导致解除阻塞的线程是从因调用该对象的 wait() 方法而阻塞的线程中随机选取的,我们无法预料哪一个线程将会被选择,所以编程时要特别小心,避免因这种不确定性而产生问题。
  • notifyAll() 也可起到类似作用,唯一的区别在于,调用 notifyAll() 方法将把因调用该对象的 wait() 方法而阻塞的所有线程一次性全部解除阻塞。当然,只有获得锁的那一个线程才能进入可执行状态。
  • 两者最⼤的区别:
    • notifyAll使所有原来在该对象上等待被notify的线程统统退出wait的状态,变成等待该对象上的锁,⼀旦该对象被解锁,他们就会去竞争。
    • notify他只是选择⼀个wait状态线程进⾏通知,并使它获得该对象上的锁,但不惊动其他同样在等待被该对象notify的线程们,当第⼀个线程运⾏完毕以后释放对象上的锁,此时如果该对象没有再次使⽤notify语句,即便该对象已经空闲,其他wait状态等待的线程由于没有得到该对象的通知,继续处在wait状态,直到这个对象发出⼀个notify或notifyAll,它们等待的是被notify或notifyAll,⽽不是锁。

有三个线程T1,T2,T3,如何保证顺序执行

在多线程中有多种方法让线程按特定顺序执行,你可以用线程类的join()方法在一个线程中启动另一个

线程,另外一个线程完成该线程继续执行。为了确保三个线程的顺序你应该先启动最后一个(T3调用

T2,T2调用T1),这样T1就会先完成而T3最后完成。

public class JoinTest2 { 
// 1.现在有T1、T2、T3三个线程,你怎样保证T2在T1执行完后执行,T3在T2执行完后执行 
  public static void main(String[] args) {
    final Thread t1 = new Thread(new Runnable() {
      @Override
      public void run() {
        System.out.println("t1");
      } }); 
    final Thread t2 = new Thread(new Runnable() {
      @Override 
      public void run() {
        try {
          // 引用t1线程,等待t1线程执行完 
          t1.join(); 
        } catch (InterruptedException e) {
          e.printStackTrace(); 
        }
        System.out.println("t2"); 
      }
      }); 
    Thread t3 = new Thread(new Runnable() {
      @Override 
      public void run() {
        try {
          // 引用t2线程,等待t2线程执行完 
          t2.join(); 
        } catch (InterruptedException e) {
          e.printStackTrace(); 
        }
        System.out.println("t3"); 
      }
      }); 
    t3.start();
    //这里三个线程的启动顺序可以任意,大家可以试下! 
    t2.start(); 
    t1.start(); 
  } 
}

在多线程中,什么是上下文切换(context-switching)?

  • 上下文切换是存储和恢复CPU状态的过程,它使得线程执行能够从中断点恢复执行。上下文切换是多任务操作系统和多线程环境的基本特征。
  • 多线程编程中⼀般线程的个数都⼤于 CPU 核⼼的个数,⽽⼀个 CPU 核⼼在任意时刻只能被⼀个线程使⽤,为了让这些线程都能得到有效执⾏,CPU 采取的策略是为每个线程分配时间⽚并轮转的形式。当⼀个线程的时间⽚⽤完的时候就会重新处于就绪状态让给其他线程使⽤,这个过程就属于⼀次上下⽂切换。
  • 概括来说就是:当前任务在执⾏完 CPU 时间⽚切换到另⼀个任务之前会先保存⾃⼰的状态,以便下次再切换回这个任务时,可以再加载这个任务的状态。任务从保存到再加载的过程就是⼀次上下⽂切换。上下⽂切换通常是计算密集型的。也就是说,它需要相当可观的处理器时间,在每秒⼏⼗上百次的切换中,每次切换都需要纳秒量级的时间。所以,上下⽂切换对系统来说意味着消耗⼤量的 CPU 时间,事实上,可能是操作系统中时间消耗最⼤的操作。
  • Linux 相⽐与其他操作系统(包括其他类 Unix 系统)有很多的优点,其中有⼀项就是,其上下⽂切换和模式切换的时间消耗⾮常少。

为什么线程通信的方法wait(), notify()和notifyAll()被定义在Object类里

  • Java的每个对象中都有一个锁(monitor,也可以成为监视器) 并且wait(),notify()等方法用于等待对象的锁或者通知其他线程对象的监视器可用。在Java的线程中并没有可供任何对象使用的锁和同步器。这就是为什么这些方法是Object类的一部分,这样Java的每一个类都有用于线程间通信的基本方法。

为什么wait(), notify()和notifyAll()必须在同步方法或者同步块中被调用?

  • 当一个线程需要调用对象的wait()方法的时候,这个线程必须拥有该对象的锁,接着它就会释放这个对象锁并进入等待状态直到其他线程调用这个对象上的notify()方法。同样的,当一个线程需要调用对象的notify()方法时,它会释放这个对象的锁,以便其他在等待的线程就可以得到这个对象锁。由于所有的这些方法都需要线程持有对象的锁,这样就只能通过同步来实现,所以他们只能在同步方法或者同步块中被调用。

为什么Thread类的sleep()和yield()方法是静态的?

  • Thread类的sleep()和yield()方法将在当前正在执行的线程上运行。所以在其他处于等待状态的线程上调用这些方法是没有意义的。这就是为什么这些方法是静态的。它们可以在当前正在执行的线程中工作,并避免程序员错误的认为可以在其他非运行线程调用这些方法。

interrupted和isInterrupted⽅法的区别

  • interrupted() :会将中断状态清除,Java多线程的中断机制是⽤内部标识来实现的,调⽤Thread.interrupt()来中断⼀个线程就会设置中断标识为true。当中断线程调⽤静态⽅法Thread.interrupted()来检查中断状态时,中断状态会被清零。

  • isInterruptedd : 不会将中断状态清除,⾮静态⽅法isInterrupted()⽤来查询其它线程的中断状态且不会改变中断状态标识。

  • 任何抛出InterruptedException异常的⽅法都会将中断状态清零。⽆论如何,⼀个线程的中断状态有有可能被其它线程调⽤中断来改变。

小结

线程状态在新建、就绪、运行、阻塞与终止之间流转;start 创建新线程执行 run,wait 释放锁而 sleep 不释放,notify 与 notifyAll 的唤醒范围不同。

最近更新: 2026/11/20 22:35
Contributors: 庆峰
Prev
Java 核心:关键字、异常与反射
Next
Java 核心:同步关键字与线程池