JUC学习笔记——进程与线程

阅读原文时间：2023年07月08日阅读：3

JUC学习笔记——进程与线程

在本系列内容中我们会对JUC做一个系统的学习，本片将会介绍JUC的进程与线程部分

我们会分为以下几部分进行介绍：

进程与线程
并发与并行
同步与异步
线程详解

在这一小节我们将简单介绍进程与线程

进程

首先我们来简单了解一下程序：

程序由指令和数据组成，我们必须将指令加载至 CPU，数据加载至内存。在指令运行过程中还需要用到磁盘、网络等设备。

接下来我们才能讲解进程的定义：

进程就是用来加载指令、管理内存、管理 IO 的
当一个程序被运行，从磁盘加载这个程序的代码至内存，这时就开启了一个进程。
进程就可以视为程序的一个实例。大部分程序可以同时运行多个实例进程，也有的程序只能启动一个实例进程。

线程

我们来简单介绍一下线程：

一个进程之内可以分为一到多个线程。
一个线程就是一个指令流，将指令流中的一条条指令以一定的顺序交给 CPU 执行
Java 中，线程作为最小调度单位，进程作为资源分配的最小单位。在 windows 中进程是不活动的，只是作为线程的容器

两者区别

我们来介绍一下进程与线程之间的区别：

进程基本上相互独立的，而线程存在于进程内，是进程的一个子集
进程拥有共享的资源，如内存空间等，供其内部的线程共享
线程更轻量，线程上下文切换成本一般上要比进程上下文切换低

此外两者的通信方式也不相同：

进程通信：同一台计算机的进程通信称为 IPC；不同计算机之间的进程通信，需要通过网络，并遵守共同的协议，例如 HTTP
线程通信：线程通信相对简单，因为它们共享进程内的内存，一个例子是多个线程可以访问同一个共享变量

在这一小节我们将简单介绍并发与并行

并发

首先我们需要了解一下任务调度器：

单核 cpu 下，线程实际还是串行执行的。
操作系统中有一个组件叫做任务调度器，将 cpu 的时间片分给不同的程序使用。

那么我们的并发实际上就是根据任务调度器来工作的：

并发是借助任务调度器，在一段时间段内将CPU分给多个线程使用，但由于切换快时间短，所以被看作是同时进行
一般会将这种线程轮流使用 CPU 的做法称为并发
实际上并发的情况是：微观串行，宏观并行

通俗来讲：

并发（concurrent）是同一时间应对（dealing with）多件事情的能力

例如下图：

CPU

时间片 1

时间片 2

时间片 3

时间片 4

core

线程 1

线程 2

线程 3

线程 4

并行

并行的概念就相对而言比较简单了：

并行就是借助多核CPU，确确实实地在同一时间执行多个进程

通俗来讲：

并行（parallel）是同一时间动手做（doing）多件事情的能力

例如下图：

CPU

时间片 1

时间片 2

时间片 3

时间片 4

core 1

线程 1

线程 3

core 2

线程 2

线程 4

线程 2

线程 4

在这一小节我们将简单介绍并发与并行

同步与异步概念

首先我们来简单介绍一下同步与异步：

需要等待结果返回才能继续执行的操作就是同步操作
不需要等待结果返回就可以继续执行的操作就是异步操作

另外同步操作还有另一个概念：

在多线程中，表示多线程的步调一致

同步与异步选择方法

我们的同步与异步的选择通常会决定程序的运行速度，因而选择同步或异步是非常重要的

我们先来介绍同步与异步的实现方式：

同步就是在一个线程内完全执行所有命令
异步可以在多线程中实现，当一个线程执行复杂操作比较耗时时，另一个线程可以执行其他简单操作

我们再来介绍同步与异步的选择方法：

针对比较繁琐的操作，我们通常会单独创建一个新线程来进行处理，避免阻塞主线程
Tomcat里面的异步Servlet也是异步操作，让用户线程处理耗时较长的操作，避免阻塞Tomcat的工作线程
UI程序中，开线程进行其他操作，避免UI线程

我们分别给出同步异步的代码展示：

// 同步代码

package cn.itcast.n2;

import cn.itcast.Constants;
import cn.itcast.n2.util.FileReader;
import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Sync")
public class Sync {

    public static void main(String[] args) {
        FileReader.read(Constants.MP4_FULL_PATH);
        log.debug("do other things ...");
    }

}

// 异步代码

package cn.itcast.n2;

import cn.itcast.Constants;
import cn.itcast.n2.util.FileReader;
import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Async")
public class Async {

    public static void main(String[] args) {
        new Thread(() -> FileReader.read(Constants.MP4_FULL_PATH)).start();
        log.debug("do other things ...");
    }

}

同步与异步实际使用

我们通常采用异步操作来实现应用的速度提升：

// 例如我们有下面三个操作

计算 1 花费 10 ms
计算 2 花费 11 ms
计算 3 花费 9 ms
汇总需要 1 ms

如果我们采用主线程的同步操作来实现：

// 如果是串行执行，那么总共花费的时间是 10 + 11 + 9 + 1 = 31ms

但是如果我们采用三个CPU的异步操作来实现：

// 但如果是四核 cpu，各个核心分别使用线程 1 执行计算 1，线程 2 执行计算 2，线程 3 执行计算 3
// 那么 3 个线程是并行的，花费时间只取决于最长的那个线程运行的时间，即 11ms 最后加上汇总时间只会花费 12ms

下面我们给出同步异步的实际使用规则：

多核多线程速度快于单核多线程（异步进行速度较快）
单核多线程速度慢于单核单线程（线程切换也需要耗费时间）

但是单核多线程也并非是一无是处：

单核 cpu 下，多线程不能实际提高程序运行效率，只是为了能够在不同的任务之间切换
不同线程轮流使用cpu ，不至于一个线程总占用 cpu，别的线程没法干活

此外多核 cpu 可以并行跑多个线程，但能否提高程序运行效率还是要分情况的：

有些任务，经过精心设计，将任务拆分，并行执行，当然可以提高程序的运行效率。但不是所有计算任务都能拆分
也不是所有任务都需要拆分，任务的目的如果不同，谈拆分和效率没啥意义

最后就是我们的IO操作部分：

IO 操作不占用 cpu，只是我们一般拷贝文件使用的是【阻塞 IO】
这时相当于线程虽然不用 cpu，但需要一直等待 IO 结束，没能充分利用线程
所以才有后面的【非阻塞 IO】和【异步 IO】优化

这一小节我们将详细介绍线程的具体内容

创建和运行线程

我们下面将介绍三种创建和运行线程的方法

直接使用 Thread

我们可以直接使用Thread来创建和运行线程：

// 创建线程对象
Thread t = new Thread() {
    public void run() {
        // 要执行的任务
    }
};
// 启动线程
t.start();

我们再给出一个实际例子：

// 构造方法的参数是给线程指定名字，推荐
Thread t1 = new Thread("t1") {
    @Override
    // run 方法内实现了要执行的任务
    public void run() {
        log.debug("hello");
    }
};
t1.start();

我们给出实际输出结果：

// 我们会注意到：前面标记了[t1]线程~
19:19:00 [t1] c.ThreadStarter - hello

使用 Runnable 配合 Thread

这里我们将Thread里面的方法采用Runnable类型的方法来代替：

// 创建Runnable类型的方法
Runnable runnable = new Runnable() {
    public void run(){
        // 要执行的任务
    }
};
// 创建线程对象
Thread t = new Thread( runnable );
// 启动线程
t.start();

我们给出一个实际例子：

// 创建任务对象
Runnable task2 = new Runnable() {
    @Override
    public void run() {
        log.debug("hello");
    }
};
// 参数1 是任务对象; 参数2 是线程名字，推荐
Thread t2 = new Thread(task2, "t2");
t2.start();

其结果为：

// 结果正常
9:19:00 [t2] c.ThreadStarter - hello

除此之外，我们在JDK8之后，我们可以采用函数式接口Lambda来简化Runnable的书写：

// 创建任务对象
Runnable task2 = () -> log.debug("hello");
// 参数1 是任务对象; 参数2 是线程名字，推荐
Thread t2 = new Thread(task2, "t2");
t2.start();

甚至我们都不用定义task，来直接采用Lambda方法书写Thread中的task：

// 参数1 是任务对象; 参数2 是线程名字，推荐
Thread t2 = new Thread(() -> log.debug("hello"), "t2");
t2.start();

底层简单解释：

至于Thread为什么能够直接调用Runnable
Thread在接收Runnable类型后，会将其赋值在this.target
而Thread的run方法会先来判断是否存在target，如果存在就直接采用target方法

最后我们介绍一下使用Runnable的好处：

方法1 是把线程和任务合并在了一起，方法2 是把线程和任务分开了
用 Runnable 更容易与线程池等高级API 配合
用 Runnable 让任务类脱离了 Thread 继承体系，更灵活

使用FutureTask 配合 Thread(了解即可)

FutureTask 能够接收 Callable 类型的参数，用来处理有返回结果的情况：

// 创建任务对象(Integer是返回对象)
FutureTask<Integer> task3 = new FutureTask<>(() -> {
    log.debug("hello");
    return 100;
});
// 参数1 是任务对象; 参数2 是线程名字，推荐
new Thread(task3, "t3").start();
// 主线程阻塞，同步等待 task 执行完毕的结果
Integer result = task3.get();
log.debug("结果是:{}", result);

我们给出结果：

19:22:27 [t3] c.ThreadStarter - hello
19:22:27 [main] c.ThreadStarter - 结果是:100

我们给出简单解释：

FutureTask内置了一个Callable对象，初始化方法将指定的Callable赋给这个对象。
FutureTask实现了Runnable接口，并重写了Run方法，在Run方法中调用了Callable中的call方法，并将返回值赋值给outcome变量
get方法就是取出outcome的值。

多线程运行状况

我们给出单核CPU运行多线程时不断切换进程的状况展示：

// 下述的操作不受我们控制，谁先调用，调用多久都不是我们管控的

@Slf4j(topic = "c.TestMultiThread")
public class TestMultiThread {

    public static void main(String[] args) {
        new Thread(() -> {
            while(true) {
                log.debug("running");
            }
        },"t1").start();
        new Thread(() -> {
            while(true) {
                log.debug("running");
            }
        },"t2").start();
    }
}

我们直接给出结果展示：

23:45:26.254 c.TestMultiThread [t2] - running
23:45:26.254 c.TestMultiThread [t2] - running
23:45:26.254 c.TestMultiThread [t2] - running
23:45:26.254 c.TestMultiThread [t2] - running
23:45:26.254 c.TestMultiThread [t1] - running
23:45:26.254 c.TestMultiThread [t1] - running
23:45:26.254 c.TestMultiThread [t1] - running
23:45:26.254 c.TestMultiThread [t1] - running
23:45:26.254 c.TestMultiThread [t1] - running
23:45:26.254 c.TestMultiThread [t1] - running

查看进程线程方法

由于不同系统的查看方法不同，我们主要介绍三种类型查看方法

Window

任务管理器可以查看进程和线程数，也可以用来杀死进程
tasklist 查看进程：tasklist| findstr (查找关键字)
taskkill 杀死进程：taskkill /F(彻底杀死）/PID(进程PID)

Linux

ps -fe 查看所有进程
ps -fT -p 查看某个进程（PID）的所有线程
kill 杀死进程 top 按大写 H 切换是否显示线程
top -H -p 查看某个进程（PID）的所有线程

Java

jps 命令查看所有 Java 进程
jstack 查看某个 Java 进程（PID）的所有线程状态
jconsole 来查看某个 Java 进程中线程的运行情况（图形界面）

线程运行底层解释

我们将会介绍两个与线程底层运行相关的原理

栈与栈帧

下面我们来介绍一下与进程息息相关的底层原理：

栈：存放栈帧的个体，每个线程具有一个单独的栈来存放多个栈帧
栈帧：方法的全部内存占用，每个方法使用时的全部内存都用一个栈帧来表示

同时栈和栈帧也有一定限制：

每个栈由多个栈帧（Frame）组成，对应着每次方法调用时所占用的内存
每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

我们给出一个简单的代码展示：

// 这里展现的是单线程，目前只有一个栈！

package cn.itcast.n3;

public class TestFrames {

    // 首先main方法被调用，所以main方法先进入栈中，在main方法执行结束后被抛出栈
    public static void main(String[] args) {
        method1(10);
    }

    // 由于main方法调用了method1，所以栈中在存有main栈帧的同时也将method1栈帧调入，在method1方法执行完毕后抛出
    private static void method1(int x) {
        int y = x + 1;
        Object m = method2();
        System.out.println(m);
    }

    // 由于method1方法调用了method2，所以栈中在存有main，method1栈帧的同时也将method2栈帧调入，method2方法执行完毕后抛出
    private static Object method2() {
        Object n = new Object();
        return n;
    }
}

// 这里展现的是多线程，主线程和线程t1独自各占有一个栈，互不影响！

package cn.itcast.n3;

public class TestFrames {
    // 这里会产生两个栈，两个栈互不影响，两个栈都会顺序调用main，method1，method2栈帧，顺序不定
    public static void main(String[] args) {
        Thread t1 = new Thread(){
            @Override
            public void run() {
                method1(20);
            }
        };
        t1.setName("t1");
        t1.start();
        method1(10);
    }

    private static void method1(int x) {
        int y = x + 1;
        Object m = method2();
        System.out.println(m);
    }

    private static Object method2() {
        Object n = new Object();
        return n;
    }
}

线程上下文切换

我们再来介绍一下上下文切换：

当出现一些状况时，系统会自动将CPU的使用权进行切换，交付给不同的线程进行使用

上下文切换措施：

要由操作系统保存当前线程的状态，并恢复另一个线程的状态，
Java 中对应的就是程序计数器，它的作用是记住下一条 jvm 指令的执行地址，是线程私有的
状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等

上下文切换时机：

线程的 cpu 时间片用完
垃圾回收
有更高优先级的线程需要运行
线程自己调用了 sleep、yield、wait、join、park、synchronized、lock 等方法

但是我们需要注意：

Context Switch 频繁发生会影响性能

这一小节我们将介绍线程的各种方法

线程方法总述

我们首先给出线程的全部方法一览：

方法

功能

说明

public void start()

启动一个新线程；Java虚拟机调用此线程的run方法

start 方法只是让线程进入就绪，里面代码不一定立刻运行（CPU 的时间片还没分给它）。每个线程对象的 start方法只能调用一次，如果调用了多次会出现 IllegalThreadStateException

public void run()

线程启动后调用该方法

如果在构造 Thread 对象时传递了 Runnable 参数，则线程启动后会调用 Runnable 中的 run 方法，否则默认不执行任何操作。但可以创建 Thread 的子类对象，来覆盖默认行为

public void setName(String name)

给当前线程取名字

public void getName()

获取当前线程的名字。线程存在默认名称：子线程是Thread-索引，主线程是main

public static Thread currentThread()

获取当前线程对象，代码在哪个线程中执行

public static void sleep(long time)

让当前线程休眠多少毫秒再继续执行。Thread.sleep(0) : 让操作系统立刻重新进行一次cpu竞争

public static native void yield()

提示线程调度器让出当前线程对CPU的使用

主要是为了测试和调试

public final int getPriority()

返回此线程的优先级

public final void setPriority(int priority)

更改此线程的优先级，常用1 5 10

java中规定线程优先级是1~10 的整数，较大的优先级能提高该线程被 CPU 调度的机率

public void interrupt()

中断这个线程，异常处理机制

public static boolean interrupted()

判断当前线程是否被打断，清除打断标记

public boolean isInterrupted()

判断当前线程是否被打断，不清除打断标记

public final void join()

等待这个线程结束

public final void join(long millis)

等待这个线程死亡millis毫秒，0意味着永远等待

public final native boolean isAlive()

线程是否存活（还没有运行完毕）

public final void setDaemon(boolean on)

将此线程标记为守护线程或用户线程

public long getId()

获取线程长整型的 id

id 唯一

public state getState()

获取线程状态

Java 中线程状态是用 6 个 enum 表示，分别为： NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED

public boolean isInterrupted()

判断是否被打断

不会清除打断标记

start与run

我们首先来介绍线程的两个相似的启动方法：

// 首先我们采用start：start方法是启动该线程，线程开始运行

public static void main(String[] args) {
    Thread t1 = new Thread("t1") {
        @Override
        public void run() {
            log.debug(Thread.currentThread().getName());
            FileReader.read(Constants.MP4_FULL_PATH);
        }
    };
    t1.start();
    log.debug("do other things ...");
}

// 然后我们直接使用run方法：run方法是调用该线程的run方法，实际是main线程在运行t1线程的run方法

public static void main(String[] args) {
    Thread t1 = new Thread("t1") {
        @Override
        public void run() {
            log.debug(Thread.currentThread().getName());
            FileReader.read(Constants.MP4_FULL_PATH);
        }
    };
    t1.run();
    log.debug("do other things ...");
}

同时我们可以通过查看线程状态来判断start和run的区别：

// 这里我们仅对start判断

public static void main(String[] args) {
    Thread t1 = new Thread("t1") {
        @Override
        public void run() {
            log.debug("running...");
        }
    };
    System.out.println(t1.getState());
    t1.start();
    System.out.println(t1.getState());
}

// 我们可以注意到main状态从就绪状态切换为Runnable
NEW
RUNNABLE
03:45:12.255 c.Test5 [t1] - running...

所以我们给出小结：

直接调用 run 是在主线程中执行了 run，没有启动新的线程
使用 start 是启动新的线程，通过新的线程间接执行 run 中的代码

sleep 与 yield

我们首先给出sleep的相关解释：

调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）
其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException
睡眠结束后的线程未必会立刻得到执行
建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性。其底层还是sleep方法
在循环访问锁的过程中，可以加入sleep让线程阻塞时间，防止大量占用cpu资源

我们再给出yield的相关解释：

调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后调度执行其它线程；具体的实现依赖于操作系统的任务调度器
加入当前线程中只有这一个方法，那么停止该方法执行后仍旧执行该方法

我们采用代码来进行展示：

/*sleep状态转换:我们运行下面代码后可以看到其t1状态从就绪状态到Runnable到Timed Waiting*/

public static void main(String[] args) {
    Thread t1 = new Thread("t1") {
        @Override
        public void run() {
            log.debug("running...");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                log.debug("wake up...");
                e.printStackTrace();
            }
        }
    };
    System.out.println(t1.getState());
    t1.start();
    System.out.println(t1.getState());
    Thread.sleep(2000);
    System.out.println(t1.getState());
}

/*sleep打断睡眠线程，抛出异常：注意当睡眠时抛出异常后该程序的打断状态为false*/ 

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread("t1") {
        @Override
        public void run() {
            log.debug("enter sleep...");
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                log.debug("wake up...");
                e.printStackTrace();
            }
        }
    };
    t1.start();

    Thread.sleep(1000);
    log.debug("interrupt...");
    t1.interrupt();
}

// 输出结果为：
03:47:18.141 c.Test7 [t1] - enter sleep...
03:47:19.132 c.Test7 [main] - interrupt...
03:47:19.132 c.Test7 [t1] - wake up...
java.lang.InterruptedException: sleep interrupted
    at java.lang.Thread.sleep(Native Method)
    at cn.itcast.test.Test7$1.run(Test7.java:14)

/*sleep采用TimeUnit的方法更具有代码可读性*/

@Slf4j(topic = "c.Test8")
public class Test8 {

    public static void main(String[] args) throws InterruptedException {
        log.debug("enter");
        TimeUnit.SECONDS.sleep(1);
        log.debug("end");
//        Thread.sleep(1000);
    }
}

/*yield简单测试：我们需要在Linux虚拟机中使用单核cpu来处理该代码，下面我们同时使用一个cpu处理两个进程*/

@Slf4j(topic = "c.TestYield")
public class TestYield {
    public static void main(String[] args) {
        Runnable task1 = () -> {
            int count = 0;
            for (;;) {
                System.out.println("---->1 " + count++);
            }
        };
        Runnable task2 = () -> {
            int count = 0;
            for (;;) {
                Thread.yield();
                System.out.println("---->2 " + count++);
            }
        };
        Thread t1 = new Thread(task1, "t1");
        Thread t2 = new Thread(task2, "t2");
        t1.start();
        t2.start();
    }
}

// 我们会发现task1的count数更多，因为轮到task2时，它会调用yield可能会导致当前线程停止从而去运行另一个线程
---->1 119199
---->2 101074

最后我们讲解一个项目中常用的案例：

// 在没有利用 cpu 来计算时，不要让 while(true) 空转浪费 cpu，这时可以使用 yield 或 sleep 来让出 cpu 的使用权 给其他程序

while(true) {
    try {
        Thread.sleep(50);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

// - 可以用 wait 或 条件变量达到类似的效果
// - 不同的是，后两种都需要加锁，并且需要相应的唤醒操作，一般适用于要进行同步的场景
// - sleep 适用于无需锁同步的场景

// wait实现

synchronized(锁对象) {
    while(条件不满足) {
        try {
            锁对象.wait();
        } catch(InterruptedException e) {
            e.printStackTrace();
        }
    }
    // do sth...
}

// 条件变量实现

lock.lock();
try {
    while(条件不满足) {
        try {
            条件变量.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    // do sth...
} finally {
    lock.unlock();
}

Priority

下面我们来介绍线程的优先级设置：

首先优先级的大小从1~10，默认为5
优先级只是起到一定影响作用，不会对线程的执行顺序起到绝对作用，只是优先级越高其获得CPU可能性越大

我们给出简单代码示例：

// 我们同样需要在单核CPU下进行

@Slf4j(topic = "c.TestYield")
public class TestYield {
    public static void main(String[] args) {
        Runnable task1 = () -> {
            int count = 0;
            for (;;) {
                System.out.println("---->1 " + count++);
            }
        };
        Runnable task2 = () -> {
            int count = 0;
            for (;;) {
                System.out.println("              ---->2 " + count++);
            }
        };
        Thread t1 = new Thread(task1, "t1");
        Thread t2 = new Thread(task2, "t2");
        t1.setPriority(Thread.MIN_PRIORITY);
        t2.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        t2.start();
    }
}

// 运行结果：我们会发现t2的执行次数明显高于t1
---->1 283500
---->2 374389

join

首先我们需要了解join的作用：

用于等待直至所指线程结束为止

我们采用一个简单的例子进行解释：

// 下述例子我们希望打印线程t1的r的值，但是我们都知道main和t1线程都是同时运行的，并且t1等待了1s，所以这时的r是没有赋值的，为0

static int r = 0;
public static void main(String[] args) throws InterruptedException {
    test1();
}
private static void test1() throws InterruptedException {
    log.debug("开始");
    Thread t1 = new Thread(() -> {
        log.debug("开始");
        sleep(1);
        log.debug("结束");
        r = 10;
    });
    t1.start();
    log.debug("结果为:{}", r);
    log.debug("结束");
}

// 但是我们可以选择使用join方法来使主线程等待，知道t1线程结束后再去运行main线程

static int r = 0;
public static void main(String[] args) throws InterruptedException {
    test1();
}
private static void test1() throws InterruptedException {
    log.debug("开始");
    Thread t1 = new Thread(() -> {
        log.debug("开始");
        sleep(1);
        log.debug("结束");
        r = 10;
    });
    t1.start();
    log.debug("结果为:{}", r);
    t1.join();
    log.debug("结果为:{}", r);
    log.debug("结束");
}

// 注意我们如果采用sleep或许也可以实现相同的效果，但是很难准确确定其实际线程的结束时刻，所以正常情况下无法使用sleep

此外我们还需要讲解join的其他几个性质：

我们可以借助join来实现线程之间的同步操作
当多个线程都采用join时，我们需要等所有线程都结束后继续运行
join是可以设置时效性的，当超过时则不再等待而是直接运行，若不超过就按照线程结束时间计算

我们通过几个案例解释上述性质：

// 借助join完成线程之间的同步操作（其实前面第一个例子就是同步操作，我们需要先完成t1线程才能执行main线程的内容）

static int r = 0;
public static void main(String[] args) throws InterruptedException {
    test1();
}
private static void test1() throws InterruptedException {
    log.debug("开始");
    Thread t1 = new Thread(() -> {
        log.debug("开始");
        sleep(1);
        log.debug("结束");
        r = 10;
    });
    t1.start();
    t1.join();
    log.debug("结果为:{}", r);
    log.debug("结束");
}

// 多个join需要等待所有线程完成
// 如下述，一个需要1s，一个需要2s,但由于同时进行，所以我们只需要2s就可以全部执行，然后再执行main

static int r1 = 0;
static int r2 = 0;
public static void main(String[] args) throws InterruptedException {
    test2();
}
private static void test2() throws InterruptedException {
    Thread t1 = new Thread(() -> {
        sleep(1);
        r1 = 10;
    });
    Thread t2 = new Thread(() -> {
        sleep(2);
        r2 = 20;
    });
    long start = System.currentTimeMillis();
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    long end = System.currentTimeMillis();
    log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
}  

// join是可以设置时效性的，当超过时则不再等待而是直接运行，若不超过就按照线程结束时间计算

static int r1 = 0;
static int r2 = 0;
public static void main(String[] args) throws InterruptedException {
    test3();
}
public static void test3() throws InterruptedException {
    Thread t1 = new Thread(() -> {
        // 这里设置时间，若低于1.5s按sleep时间执行；若高于1.5s则在1.5s时执行
        sleep(1);
        r1 = 10;
    });
    long start = System.currentTimeMillis();
    t1.start();
    // 线程执行结束会导致 join 结束
    t1.join(1500);
    long end = System.currentTimeMillis();
    log.debug("r1: {} r2: {} cost: {}", r1, r2, end - start);
}

interrupt

我们首先来简单介绍一下interrupt方法：

翻译过来就是打断，本质是将线程的打断标记设为true，并调用线程的三个parker对象（C++实现级别）unpark该线程。

我们来进行更详细的介绍：

打断操作实际上只是通知，不是打断
打断线程不等于中断线程，有以下两种情况：
打断正在运行中的线程并不会影响线程的运行，但如果线程监测到了打断标记为true，可以自行决定后续处理。
打断阻塞中的线程会让此线程产生一个InterruptedException异常，结束线程的运行。
但如果该异常被线程捕获住，该线程依然可以自行决定后续处理（终止运行，继续运行，做一些善后工作等等）

总而言之我们的打断其实主要分为两种类型，我们采用代码解释：

/* 正常运行情况下打断，并不会影响线程正常运行，但是会将线程的打断标记设置为true */

package cn.itcast.test;

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.Test12")
public class Test12 {

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            // 这里就是一个正常运行的线程，我们在启动后1s对他进行打断
            while(true) {
                // 打断不会直接对线程造成影响，但是会将打断状态interrupted变为true（由isInterrupted方法得到）
                boolean interrupted = Thread.currentThread().isInterrupted();
                // 然后我们可以自行根据打断状态来做对应处理！
                if(interrupted) {
                    log.debug("被打断了, 退出循环");
                    break;
                }
            }
        }, "t1");
        t1.start();

        // 1s后实现打断操作
        Thread.sleep(1000);
        log.debug("interrupt");
        t1.interrupt();
    }
}

// 产生结果为：程序不停止，但打断状态为true
20:57:37.964 [t2] c.TestInterrupt - 打断状态: true

/* 不正常状态被打断，例如sleep，yield，join，会使线程进入阻塞状态，抛出异常，会清空打断状态，使其变为false */

private static void test1() throws InterruptedException {
    Thread t1 = new Thread(()->{
        sleep(1);
    }, "t1");
    t1.start();
    sleep(0.5);
    t1.interrupt();
    log.debug(" 打断状态: {}", t1.isInterrupted());
}

// 产生结果为：抛出异常，但程序不会停止
java.lang.InterruptedException: sleep interrupted
 at java.lang.Thread.sleep(Native Method)
 at java.lang.Thread.sleep(Thread.java:340)
 at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
 at cn.itcast.n2.util.Sleeper.sleep(Sleeper.java:8)
 at cn.itcast.n4.TestInterrupt.lambda$test1$3(TestInterrupt.java:59)
 at java.lang.Thread.run(Thread.java:745)
21:18:10.374 [main] c.TestInterrupt - 打断状态: false

最后我们介绍一个用于interrupt的思想模式之两阶段终止:

我们需要在线程1调用线程2的interrupt方法，同时使线程2完成它的后续操作

我们首先给出其逻辑图：

我们通过代码解释：

/*首先利用isinterrupt方法来实现思想*/

// 我们需要书写一个检测类负责不断检测打断状态
class TPTInterrupt {
    private Thread thread;
    public void start(){
        thread = new Thread(() -> {
            // 首先不断检测
            while(true) {
                Thread current = Thread.currentThread();
                // 当我们发现被打断时
                if(current.isInterrupted()) {
                    // 自行处理后续内容
                    log.debug("料理后事");
                    break;
                }
                // 当我们发现没有被打断时，我们将程序停止一段时间，并进行简单处理
                try {
                    Thread.sleep(1000);
                    log.debug("将结果保存");
                } catch (InterruptedException e) {
                    // 这里我们需要注意，如果存在sleep等操作就会导致抛出异常InterruptedException
                    // 但是抛出异常并不会导致程序结束，也不会导致打断标记为true，
                    // 所以我们需要手动设置打断标记为true，使其在下一次循环时，中断程序
                    current.interrupt();
                }
                // 执行监控操作
            }
        },"监控线程");
        thread.start();
    }
    public void stop() {
        thread.interrupt();
    }
}

// 我们在主程序调用：
TPTInterrupt t = new TPTInterrupt();
t.start();
Thread.sleep(3500);
log.debug("stop");
t.stop();

// 我们可以得到结果：
11:49:42.915 c.TwoPhaseTermination [监控线程] - 将结果保存
11:49:43.919 c.TwoPhaseTermination [监控线程] - 将结果保存
11:49:44.919 c.TwoPhaseTermination [监控线程] - 将结果保存
11:49:45.413 c.TestTwoPhaseTermination [main] - stop
11:49:45.413 c.TwoPhaseTermination [监控线程] - 料理后事

/*我们还可以手动设置一个参数来负责线程的关闭*/

// 停止标记用 volatile 是为了保证该变量在多个线程之间的可见性
// 我们的例子中，即主线程把它修改为 true 对 t1 线程可见
class TPTVolatile {
    private Thread thread;
    private volatile boolean stop = false;
    public void start(){
        thread = new Thread(() -> {
            while(true) {
                Thread current = Thread.currentThread();
                if(stop) {
                    log.debug("料理后事");
                    break;
                }
                try {
                    Thread.sleep(1000);
                    log.debug("将结果保存");
                } catch (InterruptedException e) {
                }
                // 执行监控操作
            }
        },"监控线程");
        thread.start();
    }
    public void stop() {
        stop = true;
        thread.interrupt();
    }
}

// 我们在主程序中调用：
TPTVolatile t = new TPTVolatile();
t.start();
Thread.sleep(3500);
log.debug("stop");
t.stop();

// 我们得到下属结果：
11:54:52.003 c.TPTVolatile [监控线程] - 将结果保存
11:54:53.006 c.TPTVolatile [监控线程] - 将结果保存
11:54:54.007 c.TPTVolatile [监控线程] - 将结果保存
11:54:54.502 c.TestTwoPhaseTermination [main] - stop
11:54:54.502 c.TPTVolatile [监控线程] - 料理后事

/*我们还可以通过打断 park 线程来实现思想*/

// 首先我们简单介绍一下park：当打断标记为false时，park起到线程暂停作用；当打断标记为true时，继续运行

// 首先我们给出打断标记为false的状态

private static void test3() throws InterruptedException {
    Thread t1 = new Thread(() -> {
        log.debug("park...");
        LockSupport.park();
        log.debug("unpark...");
        log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
    }, "t1");
    t1.start();
    sleep(0.5);
    t1.interrupt();
}

// 我们可以得到下述结果
21:11:52.795 [t1] c.TestInterrupt - park...
21:11:53.295 [t1] c.TestInterrupt - unpark...
21:11:53.295 [t1] c.TestInterrupt - 打断状态：true 

// 如果打断标记已经是 true, 则 park 会失效

private static void test4() {
    Thread t1 = new Thread(() -> {
        for (int i = 0; i < 5; i++) {
            log.debug("park...");
            LockSupport.park();
            log.debug("打断状态：{}", Thread.currentThread().isInterrupted());
        }
    });
    t1.start();
    sleep(1);
    t1.interrupt();
}

// 我们可以得到下述结果：
21:13:48.783 [Thread-0] c.TestInterrupt - park...
21:13:49.809 [Thread-0] c.TestInterrupt - 打断状态：true
21:13:49.812 [Thread-0] c.TestInterrupt - park...
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true
21:13:49.813 [Thread-0] c.TestInterrupt - park...
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true
21:13:49.813 [Thread-0] c.TestInterrupt - park...
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true
21:13:49.813 [Thread-0] c.TestInterrupt - park...
21:13:49.813 [Thread-0] c.TestInterrupt - 打断状态：true 

// 我们可以使用 Thread.interrupted() 清除打断状态
// Thread.interrupted()获得当前打断状态，并将打断状态设置为false
// Thread.currentThread().isInterrupted())只能获得当前打断状态，不会影响值

/*
此外还有一些不符合当前状态的打断方式，我们也简单介绍一下：
- 使用线程对象的 stop() 方法停止线程
  - stop 方法会真正杀死线程，如果这时线程锁住了共享资源，那么当它被杀死后就再也没有机会释放锁， 其它线程将永远无法获取锁
- 使用 System.exit(int) 方法停止线程
  - 目的仅是停止一个线程，但这种做法会让整个程序都停止
*/

过时方法介绍

最后我们给出三个线程的过时方法简单解释：

法名

static

功能说明

stop()

停止线程运行

suspend()

挂起（暂停）线程运行

resume()

恢复线程运行

主线程和守护线程

首先我们简单介绍一下守护线程：

守护线程是不重要的线程，当所有的主线程都完成时，无论守护线程是否结束都被迫结束

我们给出简单示例：

// 主函数代码：

log.debug("开始运行...");
Thread t1 = new Thread(() -> {
     log.debug("开始运行...");
     sleep(2);
     log.debug("运行结束...");
}, "daemon");
// 设置该线程为守护线程
t1.setDaemon(true);
t1.start();
sleep(1);
log.debug("运行结束...");

// 运行结果：
08:26:38.123 [main] c.TestDaemon - 开始运行...
08:26:38.213 [daemon] c.TestDaemon - 开始运行...
08:26:39.215 [main] c.TestDaemon - 运行结束...

我们可以简单给出守护线程的一些实例：

垃圾回收器线程就是一种守护线程
Tomcat 中的 Acceptor 和 Poller 线程都是守护线程，所以 Tomcat 接收到 shutdown 命令后，不会等待它们处理完当前请求

这一小节我们将介绍线程的两种状态形式

线程五种状态

从操作系统的角度来讲，线程具有五种状态：

我们来简单介绍一下：

【初始状态】仅是在语言层面创建了线程对象，还未与操作系统线程关联
【可运行状态】（就绪状态）指该线程已经被创建（与操作系统线程关联），可以由 CPU 调度执行
【运行状态】指获取了 CPU 时间片运行中的状态
- 当 CPU 时间片用完，会从【运行状态】转换至【可运行状态】，会导致线程的上下文切换
【阻塞状态】
- 如果调用了阻塞 API，如 BIO 读写文件，这时该线程实际不会用到 CPU，会导致线程上下文切换，进入【阻塞状态】
- 等 BIO 操作完毕，会由操作系统唤醒阻塞的线程，转换至【可运行状态】
- 与【可运行状态】的区别是，对【阻塞状态】的线程来说只要它们一直不唤醒，调度器就一直不会考虑调度它们
【终止状态】表示线程已经执行完毕，生命周期已经结束，不会再转换为其它状态

线程六种状态

从Java虚拟机的角度来看，将其分为六种状态：

我们来简单介绍一下：

NEW 线程刚被创建，但是还没有调用 start() 方法
RUNNABLE 当调用了 start() 方法之后，注意，Java API 层面的 RUNNABLE 状态涵盖了操作系统层面的【可运行状态】、【运行状态】和【阻塞状态】（由于 BIO 导致的线程阻塞，在 Java 里无法区分，仍然认为是可运行）
BLOCKED ， WAITING ， TIMED_WAITING 都是 Java API 层面对【阻塞状态】的细分，后面会在状态转换一节详述
TERMINATED 当线程代码运行结束

我们给出相关代码进行解释：

package cn.itcast.n3;

import lombok.extern.slf4j.Slf4j;

import java.io.IOException;

@Slf4j(topic = "c.TestState")
public class TestState {
    public static void main(String[] args) throws IOException {

        // 代码完善，但并未运行，属于NEW状态
        Thread t1 = new Thread("t1") {
            @Override
            public void run() {
                log.debug("running...");
            }
        };

        // 代码完善且一直运行，属于runnable状态
        Thread t2 = new Thread("t2") {
            @Override
            public void run() {
                while(true) { // runnable

                }
            }
        };
        t2.start();

        // 执行一次结束，属于线程执行完毕，TERMINATED 状态
        Thread t3 = new Thread("t3") {
            @Override
            public void run() {
                log.debug("running...");
            }
        };
        t3.start();

        // 由sleep停止进程，属于timed_waiting状态
        Thread t4 = new Thread("t4") {
            @Override
            public void run() {
                synchronized (TestState.class) {
                    try {
                        Thread.sleep(1000000); // timed_waiting
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t4.start();

        // 由于等待其他进程结束而等待，属于waiting状态
        Thread t5 = new Thread("t5") {
            @Override
            public void run() {
                try {
                    t2.join(); // waiting
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };
        t5.start();

        // 由于等待锁而等待，属于blocked状态
        Thread t6 = new Thread("t6") {
            @Override
            public void run() {
                synchronized (TestState.class) { // blocked
                    try {
                        Thread.sleep(1000000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        };
        t6.start();

        try {
            Thread.sleep(500);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 输出其状态
        log.debug("t1 state {}", t1.getState());
        log.debug("t2 state {}", t2.getState());
        log.debug("t3 state {}", t3.getState());
        log.debug("t4 state {}", t4.getState());
        log.debug("t5 state {}", t5.getState());
        log.debug("t6 state {}", t6.getState());
        System.in.read();
    }
}

我们简单总结一下重点：

线程创建
线程重要 api，如 start，run，sleep，join，interrupt 等
线程状态
应用方面
- 异步调用：主线程执行期间，其它线程异步执行耗时操作
- 提高效率：并行计算，缩短运算时间
- 同步等待：join
- 统筹规划：合理使用线程，得到最优效果
原理方面
- 线程运行流程：栈、栈帧、上下文切换、程序计数器
- Thread 两种创建方式的源码
模式方面
- 终止模式之两阶段终止

结束语

到这里我们JUC的进程与线程内容就结束了，希望能为你带来帮助~

附录

该文章属于学习内容，具体参考B站黑马程序员满老师的JUC完整教程

这里附上视频链接：01.001-为什么学习并发_哔哩哔哩_bilibili

手机扫一扫

移动阅读更方便

你可能感兴趣的文章

聊聊JDK19特性之虚拟线程

万字长文浅析配置对MySQL服务器的影响

面霸的自我修养：volatile专题

Java并发(十五)----synchronized解决共享的问题