线程作为操作系统中最少调度单位,在当前系统的运行环境中,一般都拥有多核处理器,为了更好的充分利用 CPU,掌握其正确使用方式,能更高效的使程序运行。同时,在 Java 面试中,也是极其重要的一个模块。

线程简介

一个独立运行的程序是一个进程,一个进程中可以包含一个或多个线程,每个线程都有属于自己的一些属性,如堆栈,计数器等等。同时,一个线程在一个时间点上只能运行在一个 CPU 处理器核心上,不同线程之间也可以访问共享变量。线程在运行时,系统给每个线程分配一些 CPU 时间片,CPU 在时间片这段时间运行某个线程,当这个时间片运行完又跳转至下一段时间片线程,CPU 在这些线程中进行高速切换,使得程序像是在同时进行多个线程操作。

线程的实现

实现线程常用的两种方式:继承 java.lang.Thread 类、实现 java.lang.Runnable 接口。

继承 Thread 类方式

通过实例化 java.lang.Thread 类获得线程。创建 Thread 对象,一般使用继承 Thread 类的方式,然后通过方法重写覆盖 Thread 的某些方法。

首先创建一个继承 Thread 的子类。

public class DemoThread extends Thread{

    // 重写 Thread 类中的 run 方法
@Override
public void run() {
// currentThread().getName() 获取当前线程名称
System.out.println("java.lang.Thread 创建的"+ currentThread().getName() +"线程");
}
}

上面代码 DemoThread 实例化的对象就代表一个线程,通过重写 run 方法,在 run 方法中实现该线程的逻辑实现。

public class Main {

    public static void main(String[] args) {
// 实例化 DemoThread 得到新创建的线程实例
DemoThread thread = new DemoThread();
// 给创建的子线程命名
thread.setName("DemoThread 子线程");
// 启动线程
thread.start(); // 通过主线程打印信息
System.out.println("main 线程");
} }

在程序执行的主线程中创建子线程,并且命名为DemoThread 子线程,在程序的最后打印主线程打印的信息。调用线程必须调用start()方法,在调用此方法之前,子线程是不存在的,只有start()方法调用后,才是真正的创建了线程。

执行结果:

从结果可以看到,由于在主线程中创建了一个子线程,子线程相对于主线程就相当于是一个异步操作,所以打印结果就有可能main线程先于子线程执行打印操作。

实现 Runnable 接口方式

由于 Java 是单继承的特性,所以当创建线程的子类继承了其他的类,就无法实现继承操作。这时就可以通过实现 Runnable 接口,来实现线程创建的逻辑。

首先创建一个实现 Runnable 的类。

public class DemoRunnable implements Runnable {

    // 实现 Runnable 中的 run 方法
@Override
public void run() {
System.out.println("java.lang.Runnable 创建的 "+ Thread.currentThread().getName() +"线程");
}
}

Runnable 接口中定义有一个 run 方法,所以实现 Runnable 接口,就必须实现 run 方法。实际上 java.lang.Thread 类也实现了 Runnable 接口。

创建线程:

public class Main {

    public static void main(String[] args) {
// 创建 Thread 实例,并给将要创建的线程给命名
Thread thread = new Thread(new DemoRunnable(), "DemoRunnable 子线程");
// 创建一个线程
thread.start(); System.out.println("main 线程");
} }

执行结果

同样也实现了与继承 Thread 方式一样的结果。

创建 Thread 实例时,向新创建的 Thread 实例中传入了一个实现 Runnable 接口的对象的参数。

Thread 中初始化 Thread#init 的具体实现:

    private void init(ThreadGroup g, Runnable target, String name,
long stackSize, AccessControlContext acc,
boolean inheritThreadLocals) {
if (name == null) {
throw new NullPointerException("name cannot be null");
} // 给当前创建的 thread 实例中赋值线程名
this.name = name;
// 将要创建的线程的父线程即当前线程
Thread parent = currentThread();
// 添加到线程组操作
SecurityManager security = System.getSecurityManager();
if (g == null) {
if (security != null) {
g = security.getThreadGroup();
} if (g == null) {
g = parent.getThreadGroup();
}
}
g.checkAccess(); if (security != null) {
if (isCCLOverridden(getClass())) {
security.checkPermission(SUBCLASS_IMPLEMENTATION_PERMISSION);
}
}
// 线程组中添加为启动的线程数
g.addUnstarted();
this.group = g;
// 设置父线程的一些属性到当前将要创建的线程
this.daemon = parent.isDaemon();
this.priority = parent.getPriority();
if (security == null || isCCLOverridden(parent.getClass()))
this.contextClassLoader = parent.getContextClassLoader();
else
this.contextClassLoader = parent.contextClassLoader;
this.inheritedAccessControlContext =
acc != null ? acc : AccessController.getContext(); // 将当前传入 target 的参数,赋值给当前 Thread 对象,使其持有 已实现 Runnable 接口的实例
this.target = target;
setPriority(priority);
if (inheritThreadLocals && parent.inheritableThreadLocals != null)
this.inheritableThreadLocals =
ThreadLocal.createInheritedMap(parent.inheritableThreadLocals); // 设置线程的堆栈大小
this.stackSize = stackSize; // 给创建的线程一个 id
tid = nextThreadID();
}

上面代码创建 thread 对象时的 init 方法,通过传入 Runnable 的实例对象,thread 对象中就持有该对象。

创建 thread 对象后,调用 start() 方法,该线程就运行持有 Runnable 实现类对象的 run() 方法。

例如本文中案例,就会执行 DemoRunnable#run 方法的逻辑。

这两种方法创建线程的方式,具体使用哪种,根据自身需求选择。如果需要继承其他非 Thread 类,就需要使用 Runnable 接口。

线程状态

Java 线程每个时间点都存在于6种状态中一种。

状态 描述
NEW 初始状态,thread 对象调用 start() 方法前
RUNNABLE 运行状态,线程 start() 后的就绪或运行中
BLOCKED 阻塞状态,线程获得锁后的锁定状态
WAITING 等待状态,线程进入等待状态,不会被分配时间片,需要等待其他线程来唤醒
TIME_WAITING 超时等待状态,同样不分配时间片,当时间达到设定的等待时间后自动唤醒
TERMINATED 终止状态,表示当前线程执行完成

其中 NEW、RUNNABLE、TERMINATED 比较好理解,现在主要针对 BLOCKED、WAITING 和 TIME_WAITING 进行案例讲解。

BLOCKED

阻塞状态 是将两个线程之间处于竞争关系,同时在调用 run 时进行加锁。

首先还是使用上面 Runnable 实现的方式进行改造。

public class DemoRunnable implements Runnable {

    @Override
public void run() {
// 通过对DemoRunnable加同步锁,进行无限循环不退出
synchronized (DemoRunnable.class){
while (true){
System.out.println("java.lang.Runnable 创建的 "+ Thread.currentThread().getName() +"线程");
}
}
}
}

先竞争到 DemoRunnable 类的线程进入 run 会一直执行下去,未竞争到的线程则会一直处于阻塞状态。

创建两个线程

public class Main {

    public static void main(String[] args) {
// 创建两个线程测试
new Thread(new DemoRunnable(), "test-blocked-1")
.start();
new Thread(new DemoRunnable(), "test-blocked-2")
.start();
} }

通过分析执行后的线程如图:

可以得知线程test-blocked-1竞争到 DemoRunnable 类,一直都在运行 while 循环,所以状态为 RUNNABLE。由于 DemoRunnable#run 中加了同步锁锁住 DemoRunnable 类,所以test-blocked-2一直处于 BLOCKED 阻塞状态。

WAITING

等待状态 线程是不被分配 CPU 时间片,线程如果要重新被唤醒,必须显示被其它线程唤醒,否则会一直等待下去。

实现等待状态例子

public class DemoRunnable implements Runnable {

    @Override
public void run() {
while (true){
// 调用 wait 方法,使线程在当前实例上处于等待状态
synchronized (this){
try {
this.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("java.lang.Runnable 创建的 "+ Thread.currentThread().getName() +"线程");
}
}
}
} // 创建线程
public class Main { public static void main(String[] args) {
new Thread(new DemoRunnable(), "test-waiting")
.start();
} }

创建该实例线程后,分析 test-waiting 线程,该线程处于 WAITING 状态。

TIME_WAITING

超时等待状态 线程也是不被分配 CPU 时间片,但是它通过设置的间隔时间后,可以自动唤醒当前线程。也就是说,将等待状态的线程加个时间限制就是超时等待状态。

只需对上面 WAITING 状态案例增加 wait 时间限制。

public class DemoRunnable implements Runnable {

    @Override
public void run() {
while (true){
synchronized (this){
try {
// 增加等待时长
this.wait(1000000, 999999);
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("java.lang.Runnable 创建的 "+ Thread.currentThread().getName() +"线程");
}
}
}
}

分析线程结果,可以看到 test-time_waiting 线程处于超时等待状态,使用 sleep 睡眠时,线程也是属于超时等待状态。

线程状态之间的转换,如图(来源网络):

Thread 常用方法

currentThread()

currentThread 是获取当前线程实例,返回 Thread 对象,这是一个静态方法,使用如下

Thread.currentThread();

start()

start 方法是启动线程的入口方法,这个就是上面实现创建线程例子中的 start 方法。

run()

run 方法是线程创建后,线程会主动调用 run 方法执行里面的逻辑。

join()

join 方法即线程同步,比如上继承 Thread 方法实现创建线程的例子中,如果在 thread.start() 后调用 thread.join() 方法,则 main 线程打印的信息一定在子线程打印的信息之后。这里的 main 线程会等待子线程执行完后,再继续执行。

getName()

getName 返回线程名称。

getId()

获取线程 Id,这是返回一个 long 类型的 Id 值。

setDaemon()

setDaemon(boolean on) 方法是设置线程类型,setDaemon 接受一个 boolean 类型参数。设置为 true 时,线程类型为守护线程,设置为 false 时,线程类型为用户线程。

yield()

yield 方法是线程让步,让当前线程进入就绪状态,去执行其它相同优先级的线程,但不一定会执行其他线程,有可能让步后的线程再次被执行。

setPriority()

setPriority(int newPriority) 是设置线程执行的优先级,数值为1~10,默认值为5,数值越大线程越先执行。

interrupt()

interrupt 方法的作用是中断线程,但是它还是会继续运行。它只是表示其他线程给打了个中断标志。

interrupted()

interrupted 方法是检查当前线程是否被中断。调用此方法时会清除该线程的中断标志。

isInterrupted()

isInterrupted 方法检测当前线程是否被中断,如果被中断了,也不会清除中断标志。

总结

本文对线程的常用功能及概念进行了分析,主要是讲解单线程的一些操作,线程操作的使用在生产中是极容易出现问题的,所以在掌握概念和使用后,需要多研究,多思考应用的设计及实现。在掌握多线程操作时,必须对这些的基本使用和概念进行掌握,今后会出进一步对多线程分析的文章。

推荐阅读

《你必须会的 JDK 动态代理和 CGLIB 动态代理》

《Dubbo 扩展点加载机制:从 Java SPI 到 Dubbo SPI》

《volatile 手摸手带你解析》

Java 线程基础,从这篇开始的更多相关文章

  1. Java 线程基础

    Java 线程基础

  2. java 线程基础篇,看这一篇就够了。

    前言: Java三大基础框架:集合,线程,io基本是开发必用,面试必问的核心内容,今天我们讲讲线程. 想要把线程理解透彻,这需要具备很多方面的知识和经验,本篇主要是关于线程基础包括线程状态和常用方法. ...

  3. java线程基础巩固---线程生命周期以及start方法源码剖析

    上篇中介绍了如何启动一个线程,通过调用start()方法才能创建并使用新线程,并且这个start()是非阻塞的,调用之后立马就返回的,实际上它是线程生命周期环节中的一种,所以这里阐述一下线程的一个完整 ...

  4. Java线程基础实例

    概述 Java线程是一个在实战开发中经常使用的基础功能,而在Java中线程相关的类在java.lang和java.util.concurrent里 Thread package thread.base ...

  5. Java线程基础知识(状态、共享与协作)

    1.基础概念 CPU核心数和线程数的关系 核心数:线程数=1:1 ;使用了超线程技术后---> 1:2 CPU时间片轮转机制 又称RR调度,会导致上下文切换 什么是进程和线程 进程:程序运行资源 ...

  6. java线程基础知识----线程与锁

    我们上一章已经谈到java线程的基础知识,我们学习了Thread的基础知识,今天我们开始学习java线程和锁. 1. 首先我们应该了解一下Object类的一些性质以其方法,首先我们知道Object类的 ...

  7. java线程基础知识----线程基础知识

    不知道从什么时候开始,学习知识变成了一个短期记忆的过程,总是容易忘记自己当初学懂的知识(fuck!),不知道是自己没有经常使用还是当初理解的不够深入.今天准备再对java的线程进行一下系统的学习,希望 ...

  8. Java 线程基础知识

    前言 什么是线程?线程,有时被称为轻量进程(Lightweight Process,LWP),是程序执行流的最小单元.一个标准的线程由线程 ID,当前指令指针 (PC),寄存器集合和堆栈组成.另外,线 ...

  9. JAVA线程基础

    一.线程状态 由于参考的维度不一样,线程状态划分也不一样,我这里简单的分为5大类,并且会说明状态变迁的详细过程:

随机推荐

  1. Java实现 LeetCode 775 全局倒置与局部倒置(分析题)

    775. 全局倒置与局部倒置 数组 A 是 [0, 1, -, N - 1] 的一种排列,N 是数组 A 的长度.全局倒置指的是 i,j 满足 0 <= i < j < N 并且 A ...

  2. Java实现 LeetCode 771 宝石与石头(这是真暴力)

    771. 宝石与石头 给定字符串J 代表石头中宝石的类型,和字符串 S代表你拥有的石头. S 中每个字符代表了一种你拥有的石头的类型,你想知道你拥有的石头中有多少是宝石. J 中的字母不重复,J 和 ...

  3. Java实现 蓝桥杯VIP 算法提高 P0401

    算法提高 P0401 时间限制:1.0s 内存限制:256.0MB 输入一个无符号整数x,输出x的二进制表示中1的个数. 输入: 76584 输出: 7 import java.util.Scanne ...

  4. Java实现 蓝桥杯VIP 算法提高 连接乘积

    算法提高 连接乘积 时间限制:1.0s 内存限制:256.0MB 问题描述 192这个数很厉害,用它分别乘以1.2.3,会得到: 192 x 1 = 192 192 x 2 = 384 192 x 3 ...

  5. java实现多线程(车站卖票)

    import java.util.ArrayList; import java.util.List; public class 多线程 { // public static int j=0; publ ...

  6. 【图机器学习】cs224w Lecture 16 - 图神经网络的局限性

    目录 Capturing Graph Structure Graph Isomorphism Network Vulnerability to Noise 转自本人:https://blog.csdn ...

  7. uni-app动态修改顶部导航栏标题

    动态修改顶部导航栏标题有两种方法方式一.使用自定义到导航栏,覆盖原生导航栏 缺点:自定义到导航栏性能远远不如原生导航栏,手机顶部状态栏区域会被页面内容覆盖,这是因为窗体是沉浸式的原因,即全屏可写内容: ...

  8. Node.js环境安装

    为其他使用先小小的接触这个环境,如不出意外,未来的一些时候抽时间会系统的学习element-ui, JavaScript, vue, node.js, 稍后也做个简易的ACE Editor体验一下 1 ...

  9. JS之预解释原理

    预解释的原理 预解释的不同机制 var的预解释机制 function 的预解释机制 预解释机制 面试题练习 预解释的的不同机制 预解释也叫预声明,是提前解释声明的意思:预解释是针对变量和函数来说的:但 ...

  10. TypeError: this.xxx.substring is not a function的解决办法

    这是因为已经改变了xxx的值的类型,不再是字符串的话将不会拥有substring函数, 我当时这样写的时候,直接将number类型赋予了this.enter,所以导致了错误. 改为这样之后可以使用su ...