黑马程序员JUC并发教程笔记（一）

视频地址：b站视频

1. 进程与线程

1.1 进程与线程

进程

• 程序由指令和数据组成，是一个静态的概念。当程序被加载到内存中运行起来时为进程，进程是动态的概念
• 进程是用来加载指令、管理内存、管理IO的
• 当一个程序被运行，从磁盘加载这个程序的代码到内存中，这就相当于开启了一个线程
• 进程可以视为程序的一个实例

线程

• 一个进程可以有一到多个线程，最少有一个线程
• 进程是资源分配的单位；线程是cpu调度的单位。在Windows中进程是不活动的，只作为线程的容器

进程 VS 线程

• 进程之间是相互独立的，每个进程都有自己的运行空间，不允许相互窥探；线程存在于进程内，共享进行的内存
• 进程拥有非配得资源，如内存空间等，供线程共享
• 进程通信复杂
  • 同一台计算机的进程之间通信称为IPC（Inter-process communication）
  • 不同计算机（如客户机与服务器）之间的进程通信，需要通过网络，遵守共同的协议，如Http、Https
• 线程通信相对简单，因为他们共享进程的内存空间，可以通过共享变量的方式进行通信
• 线程更轻量，线程上下文切换的成本比进程低

1.2 并行与并发

并发

• 并发（Concurrent），在操作系统中，是指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行。

• 并发不是真正意义上的“同时进行”，只是CPU把一个时间段划分成几个时间片段（时间区间），然后在这几个时间区间之间来回切换，由于CPU处理的速度非常快，只要时间间隔处理得当，即可让用户感觉是多个应用程序同时在进行。如：打游戏和听音乐两件事情在同一个时间段内都是在同一台电脑上完成了从开始到结束的动作。那么，就可以说听音乐和打游戏是并发的。

并行

• 并行（Parallel），当系统有一个以上CPU时，当一个CPU执行一个进程时，另一个CPU可以执行另一个进程，两个进程互不抢占CPU资源，可以同时进行，这种方式我们称之为并行(Parallel)。

• 其实决定并行的因素不是CPU的数量，而是CPU的核心数量，比如一个CPU多个核也可以并行。

并发 VS 并行

• 并发是宏观的概念，并行是微观的概念
• 只有在多喝处理器上才会存在并行
• 并发的多个任务之间相互抢占资源
• 并行的多个任务之间不会恍惚抢夺资源

1.3 应用

1. 异步调用

• 同步：按照代码顺序执行，需要等待结果返回才能继续运行
• 异步：按照代码顺序执行，不需要等待结果返回就能继续运行
• 场景
  • 比如在项目中，视频文件需要转换格式等操作比较费时，这时开一个新线程处理视频转换，避免阻塞主线
  • tomcat 的异步 servlet 也是类似的目的，让用户线程处理耗时较长的操作，避免阻塞 tomcat 的工作线程
  • ui 程序中，开线程进行其他操作，避免阻塞 ui 线程

2. 提高效率

如果一个大的任务可以拆分为几个独立的小的任务，如$A=a1+a2+a3$​，那么大任务A就可以拆分为三个小任务。

把这三个任务放在三个线程上执行，总的任务时间取决于耗时最长的小任务，而不是三个小任务运行时长的加和

1.4 案例

1. 多线程提高效率

2. cpu占用100%

2. Java线程

2.1 创建和运行线程

1. 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();

2. Runnable

Thread是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();

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

3. FutureTask

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

// 创建任务对象
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);

2.2 查看线程运行的方法

Windows

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

Java

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

2.3 线程运行原理

线程栈与栈帧

Java Virtual Machine Stacks （Java 虚拟机栈）

JVM 中由程序计数器、堆、栈、方法区所组成，其中栈内存是给谁用的呢？其实就是线程，每个线程启动后，虚拟机就会为其分配一块栈内存。

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

线程上下文切换

线程的上下文是当前线程运行的所有内容

导致线程切换的原因：

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

当 Context Switch 发生时，需要由操作系统保存当前线程的状态，并恢复另一个线程的状态，Java 中对应的概念就是程序计数器（Program Counter Register），它的作用是记住下一条 jvm 指令的执行地址，是线程私有的

• 状态包括程序计数器、虚拟机栈中每个栈帧的信息，如局部变量、操作数栈、返回地址等
• Context Switch 频繁发生会影响性能（并不是线程越多越好）

2.4 线程方法

方法名	static	功能说明	注意
start()		启动一个新线 程，在新的线程 运行 run 方法 中的代码	start 方法只是让线程进入就绪，里面代码不一定立刻 运行（CPU 的时间片还没分给它）。每个线程对象的 start方法只能调用一次，如果调用了多次会出现 IllegalThreadStateException
run()		新线程启动后调用的方法	如果在构造 Thread 对象时传递了 Runnable 参数，则 线程启动后会调用 Runnable 中的 run 方法，否则默 认不执行任何操作。但可以创建 Thread 的子类对象， 来覆盖默认行为
join()		等待线程运行结 束，多进程之间需要通信的时候，当前线程使用join()等待其他线程执行完毕并传递结果
join(long n)		等待线程运行结 束,最多等待 n 毫秒
getId()		获取线程长整型 的 id	id 唯一
getName()		获取线程名
getName(String)		修改线程名
getPriority()		获取线程优先级
setPriority()		修改线程优先级	java中规定线程优先级是1~10 的整数，较大的优先级 能提高该线程被 CPU 调度的机率
getState()		获取线程状态	Java 中线程状态是用 6 个 enum 表示，分别为： NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED
isInterrupted()		判断是否被打 断，	不会清除打断标记
isAlive()		线程是否存活
interrupt()	static	打断线程	如果被打断线程正在 sleep，wait，join 会导致被打断的线程抛出 InterruptedException，并清除打断标 记 ；如果打断的正在运行的线程，则会设置 打断标 记 ；park 的线程被打断，也会设置 打断标记
interrupted()	static	判断当前线程是 否被打断	会清除 打断标记
currentThread()	static	获取当前正在执 行的线程
sleep(long n)	static	让当前执行的线 程休眠n毫秒， 休眠时让出 cpu 的时间片给其它 线程（sleep时不会释放锁，报锁睡觉）
yield()	static	提示线程调度器 让出当前线程对 CPU的使用，（礼让其他线程，当前线程让出cpu，进入就绪状态，与其他就绪的线程公平竞争下一cpu）

run与start

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

sleep

• 调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞）
• sleep不会释放锁
• .其它线程可以使用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出 InterruptedException
• 睡眠结束后的线程未必会立刻得到执行
• . 建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性

yield

• . 调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态，然后与其他线程同时回到出发点，竞争cpu
• 具体的实现依赖于操作系统的任务调度器

join

• join合并线程，待此线程执行完毕后，再执行其他线程，其他线程阻塞

• 可以想象成插队

interrupt

1. 打断sleep、join、wait的线程

• 这几个方法都会让线程进入阻塞状态
• 打断 sleep 的线程, 会清空打断状态，即打断状态为false

// 打断sleep线程
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

2. 打断正常的线程

• 打断正常运行的线程, 不会清空打断状态
• 正常先线程被打断后，停止与否由正常线程自己决定

private static void test2() throws InterruptedException {
 Thread t2 = new Thread(()->{
 while(true) {
 Thread current = Thread.currentThread();
 boolean interrupted = current.isInterrupted();
    //这里使用了isInterrupted（）方法判断线程状态，如果为true，就自动break
 if(interrupted) {
 log.debug(" 打断状态: {}", interrupted);
 break;
 }
 }
 }, "t2");
 t2.start();
 sleep(0.5);
 t2.interrupt();
}

// out
20:57:37.964 [t2] c.TestInterrupt - 打断状态: true 

2.5 两阶段终止模式（Two Phase Termination）

在一个线程T1中优雅的终止线程T2（优雅是指给T2一个料理后事的机会）

1. 错误的方法

1. 使用stop（）方法

stop（）方法会真正的杀死线程，这时如果线程持有其他资源，那么资源得不到释放，其他线程将永远无法获得该资源。stop（）方法已经被废弃

1. 使用Syatem.exit(init)方法

该方法会停止整个程序

2. 两阶段终止模式

package cn.itcast.test;

import lombok.extern.slf4j.Slf4j;

@Slf4j(topic = "c.TwoPhaseTermination")
public class Test13 {
    public static void main(String[] args) throws InterruptedException {
        TwoPhaseTermination tpt = new TwoPhaseTermination();
        tpt.start();
//        tpt.start();
//        tpt.start();

        Thread.sleep(3500);
        log.debug("停止监控");
        tpt.stop();
    }
}

@Slf4j(topic = "c.TwoPhaseTermination")
class TwoPhaseTermination {
    // 监控线程
    private Thread monitorThread;
    // 停止标记
    private volatile boolean stop = false;
    // 判断是否执行过 start 方法
    private boolean starting = false;

    // 启动监控线程
    public void start() {
        synchronized (this) {
            if (starting) { // false
                return;
            }
            starting = true;
        }
        monitorThread = new Thread(() -> {
            while (true) {
                Thread current = Thread.currentThread();
                // 是否被打断
                if (stop) {
                    log.debug("料理后事");
                    break;
                }
                try {
                    Thread.sleep(1000);
                    log.debug("执行监控记录");
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    //current.interrupt();//重新设置打断标记为真
                }
            }
        }, "monitor");
        monitorThread.start();
    }

    // 停止监控线程
    public void stop() {
        stop = true; //自己设置一个打断标志
        monitorThread.interrupt(); //打断
    }
}

2.6 主线程与守护线程

默认情况下，Java 进程需要等待所有线程都运行结束，才会结束。有一种特殊的线程叫做守护线程，只要其它非守 护线程运行结束了，即使守护线程的代码没有执行完，也会强制结束。

垃圾回收器线程就是一种守护线程

2.7 操作系统中五种线程状态

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

2.8 java中六种线程状态

这是从 Java API 层面来描述的。根据 Thread.State 枚举，分为六种状态

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