多线程基础

技术背景

真空管和穿孔卡片

运作方式

• 最早的计算机只能解决简单的数学运算问题。
• 程序员首先把程序写到纸上，然后穿孔成卡票，再把卡片盒带入到专门的输入室。
• 输入室会有专门的操作员将卡片的程序输入到计算机上。
• 计算机运行完当前的任务后，把计算结果从打印机上进行输出，操作员再把打印出来的结果送入到输出室，程序员就可以从输出室取到结果。
• 然后，操作员再继续从已经送入到输入室的卡片盒中读入另一个任务重复上述的步骤。

上述运作方式存在的问题

• 操作员在机房里面来回调度资源，造成计算机存在大量的空闲状态。
• 而当时的计算机是非常昂贵的，人们为了减少这种资源的浪费。就采用了 批处理系统 来解决空闲问题。

晶体管和批处理系统

运作方式

• 在输入室收集全部的作业，然后用一台比较便宜的计算机把它们读取到磁带上。
• 然后把磁带输入到计算机，计算机通过读取磁带的指令来进行运算，最后把结果输出磁带上。

上述运作方式存在的问题

• 批处理操作系统的好处在于，计算机会一直处于 运算状态，合理的利用了计算机资源。
• 批处理操作系统虽然能够解决计算机的空闲问题，但是当某一个作业因为等待磁盘或者其他 I/O 操作而暂停, 那 CPU 就只能阻塞, 直到该 I/O 完成，对于 CPU 操作密集型的程序，I/O 操作相对较少，因此浪费的时间也很少。但是对于 I/O 操作较多的场景来说，CPU 的资源是属于严重浪费的。

集成电路和多道程序设计

运作方式

• 多道程序设计的出现解决了（CPU 的资源是属于严重浪费的）这个问题，就是把内存分为几个部分，每一个部分放不同的程序。
• 当一个程序需要等待 I/O 操作完成时。那么 CPU 可以切换执行内存中的另外一个程序。
• 如果内存中可以同时存放足够多的程序，那 CPU 的利用率可以接近 100%。

进程

概述

• 进程的本质是一个正在执行的程序，程序运行时系统会创建一个进程。
• 并且给每个进程分配独立的内存地址空间保证每个进程地址不会相互干扰。
• 同时，在 CPU 对进程做时间片的切换时，保证进程切换过程中仍然要从进程切换之前运行的位置出开始执行。
• 所以进程通常还会包括 程序计数器、堆, 栈, 指针。

什么是进程

进程是操作系统资源分配的基本单位

CPU

中央处理器: 作为计算机系统的运算和控制的核心，是信息处理、程序运行的最终执行单元。

• ALU 算术逻辑单元: 是能实现多组算术运算和逻辑运算的组合逻辑电路。
• CU 控制单元: 用于执行计算机指令或者 Client Unit 监控系统的监控客户端单元。
• MMU 内存管理单元: 用于完成虚拟内存和物理内存的映射。
• Cache CPU缓存: 位于 CPU 与内存之间的临时存储器，它的容量比内存小但交换速度快。
• PC 程序计数器: 是用于存放下一条指令所在单元的地址的地方。
• Register set/Registers 寄存器组: 是 CPU 中暂时存放数据的地方，里面保存着那些等待处理的数据，或已经处理过的数据，CPU 访问寄存器所用的时间要比访问内存的时间短。

计算机的组成

线程

概述

• 平常用 word 文档编辑内容的时候, 有一个自动保存的功能, 当计算机出现故障的情况下如果用户未保存文档，则能够恢复到上一次自动保存的点。
• 假设 word 的自动保存因为磁盘问题导致写入较慢，势必会影响到用户的文档编辑功能，直到磁盘写入完成用户才可编辑，这种体验是很差的。

什么是线程

• CPU 调度执行的基本单位。
• 一个进程内有多个线程, 会共享这个进程的资源。
• 一个进程当中可以有很多的线程, 最少也要有一个 main（主要的）

线程的优势

• 线程可以认为是轻量级的进程，所以线程的创建、销毁要比进程更快。
• 从性能上考虑，如果进程中存在大量的 I/O 处理，通过多线程能够加快应用程序的执行速度(通过 CPU 时间片的快速切换)
• 由于线程是 CPU 的最小调度单元，所以在多 CPU 的架构中能够实现真正的并行执行。

线程的切换

• t1 线程执行时, CPU 把 t1 指令存放在寄存器当中。
• CU 开始执行。
• PC 记录当前执行指令行号。
• 当收到操作系统 OS 调度时, 把当前 t1 执行的数据和指令存到 Cache 中。
• 开始执行 t2 线程。
• 循环切换操作。
• CPU 时间片的轮转机制。

线程数设多少为好

1. 根据 CPU 的核数, 也不是最确定, 一台机器上还有其它程序占用 CPU 的资源, 核心数与线程数 1:1, 超线程奇数 1:2。
2. 根据压力测试得出一个合适的值。

计算线程数公式

• Ncpu: 处理器的核的数目 RunTime.getRuntime().availableProcessors() 得到。
• Ucpu: 启动 CPU 的利用率(介于 0 到 1 之前)
• W/C: 等待时间与计算时间的比较, 通过 Profiler 性能分析工具进行测算。

公式: Ncpu * Ucpu * (1 + W/C)

并行

同时执行多个任务，在多核心 CPU 架构中，一个 CPU 核心运行一个线程，那么 4 核心 CPU，可以同时执行 4 个线程。

并发

• 同时处理多个任务的能力, 通常我们会通过 TPS 或者 QPS 来表示某某系统支持的并发数是多少。
• 与时间单位相关。
• 某一个时间段内可以同时处理的事件。

创建线程的方式

继承 Thread

/**
 * @author BNTang
 */
public class MyThread extends Thread {
    @Override
    public void run() {
        System.out.println("Thread run");
    }

    public static void main(String[] args) {
        new MyThread().start();
    }
}

实现 Runnable 接口

/**
 * @author BNTang
 */
public class MyThread implements Runnable {
    @Override
    public void run() {
        System.out.println("Runnable run");
    }

    public static void main(String[] args) {
        new Thread(new MyThread()).start();
    }
}

使用 lambda 表达式

/**
 * @author BNTang
 */
public class MyThread {
    public static void main(String[] args) {
        new Thread(() -> System.out.println("lambda表达式写法")).start();
    }
}

使用线程池

/**
 * @author BNTang
 */
public class MyThread {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newCachedThreadPool();
        executorService.execute(() -> System.out.println("线程池的方式 run"));
        executorService.shutdown();
    }
}

Callable

/**
 * @author BNTang
 */
public class MyThread implements Callable<String> {
    /**
     * Callable 方式可以获取线程方法执行之后的参数
     */
    @Override
    public String call() {
        System.out.println("Callable run");
        return "Callable result";
    }

    public static void main(String[] args) throws Exception {
        // 1.使用线程池的方式执行
        ExecutorService executorService = Executors.newCachedThreadPool();
        Future<String> future = executorService.submit(new MyThread());

        // 异常执行
        String res = future.get();
        System.out.println(res);

        executorService.shutdown();
        
        // 2.FutureTask方法执行
        FutureTask<String> futureTask = new FutureTask<>(new MyThread());
        new Thread(futureTask).start();
        System.out.println(futureTask.get());
    }
}

yield 与 join

yield

• 暂停当前正在执行的线程对象，并执行其他线程。
• yield() 应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。
• 使用 yield() 的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证 yield() 达到让步目的。
• 因为让步的线程还有可能被线程调度程序再次选中。

/**
 * @author BNTang
 **/
public class TestYield {
    /**
     * 让出当前线程,进入等待状态,后续继续抢夺资源
     */
    public static void main(String[] args) {
        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println("A 🤣" + i);
                if (i % 10 == 0) Thread.yield();
            }
        }).start();

        new Thread(() -> {
            for (int i = 0; i < 100; i++) {
                System.out.println("B 🐱‍🏍" + i);
                if (i % 10 == 0) Thread.yield();
            }
        }).start();
    }
}

join

等待加入的线程结束后, 才继续执行当前线程。

创建 SleepTools.java

/**
 * @author BNTang
 */
public class SleepTools {
    public static void sleepMs(long ms) {
        try {
            Thread.sleep(ms);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void sleepSecond(long second) {
        try {
            Thread.sleep(second * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

/**
 * @author BNTang
 */
public class TestJoin {
    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 50; i++) {
                System.out.println("A 🤣" + i);
                SleepTools.sleepMs(500);
            }
        });

        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 50; i++) {
                System.out.println("B 🐱‍🏍" + i);
                if (i == 2) {
                    try {
                        t1.join();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                SleepTools.sleepMs(500);
            }
        });

        t1.start();
        t2.start();
    }
}

线程停止与线程中断

1. 自然执行完。
2. 抛出异常。
3. stop, 不建议使用, 容易产生数据不一致, 不管现在线程什么状态, 立即停止, 会释放所有的锁资源, 不会做善后的工作。
4. resume, 不建议使用。
5. suspend, 不建议使用。
6. interrupt(), 中断一个线程, Java 线程是协作式, 为了让每一个线程有自己的时间做自己的清理工作, 并不是强行关闭这个线程, interrupt() 给线程发出中断请求, 由线程自己来进行结束操作, 仅仅是把中断标志位置改为 true, 注意事项 当一个方法抛出了 InterruptedException 异常, 线程的中断标志位会被复位成 false, 需要在 catch 当中, 手动再调用 interrupt() 中断线程。
7. isInterrupted(), 判断当前线程是否属于中断状态, 判断中断标志位。
8. 静态的 interrupted, 判定当前线程是否处于中断状态, 执行完这个方法后, 会把中断标志位改为 false。

stop, resume, suspend 不会释放资源。

run 与 start

/**
 * @author BNTang
 */
public class MyThread extends Thread {

    /**
     * 创建线程时, 设置线程名称
     */
    public MyThread(String threadName) {
        super(threadName);
    }

    @Override
    public void run() {
        System.out.println("ThreadName = " + Thread.currentThread().getName());
        System.out.println("MyThread Thread run");
    }

    public static void main(String[] args) {
        MyThread myThread = new MyThread("MyThreadName");
        // 如果没有调用 start 方法时, 此时的线程还是主线程
        myThread.run();
        
        // 当调用 start 方法时, 会自动调用 run 方法, 此时的线程为新开的线程
        myThread.start();
    }
}

六种线程状态

• New(新建): 线程刚被创建, 但是并未启动。还没调用 start 方法。
• Runnable(可运行): 线程可以在 Java 虚拟机中运行的状态, 可能正在运行自己代码，也可能没有，这取决于操作系统的处理器, 被线程调度器执行, READY 暂时让出 CPU, 等着再被调度器选中执行, RUNNING 可以调用, Thread.yield 让出 CPU。
• Blocked(锁阻塞): 当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入 Blocked 状态，当该线程持有锁时，该线程将变成 Runnable 状态。
• Waiting(无限等待): 一个线程在等待另一个线程执行一个（唤醒）动作时，该线程进入 Waiting 状态。进入这个状态后是不能自动唤醒的，必须等待另一个线程调用 notify 或者 notifyAll 方法才能够唤醒。
• Timed Waiting(计时等待): 同 waiting 状态，有几个方法有超时参数，调用他们将进入 Timed Waiting 状态。这一状态将一直保持到超时期满或者接收到唤醒通知。带有超时参数的常用方法有 Thread.sleep、Object.wait。
• Terminated(被终止): 因为 run 方法正常退出而死亡，或者因为没有捕获到异常，终止了 run 方法而死亡。

线程优先级

• 线程的优先级范围 0 - 10
• 默认是 5

设置线程的优先级的方式就是调用线程的方法进行设置

线程实例对象.setPriority(3)

• 在实际上的过程操作系统当中, 线程的优先级往往是一个很难确定的东西。
• 有的甚至会忽略优先级的设置。
• 设置了, 不一定就是按照设置的方式进行, 做为了解。

守护线程

• 和主线程共存的, 只要主线程存在, 守护线程就一起存在, 主线程死亡, 守护线程也会死亡。
• 守护线程中 finally 不能保证一定执行。

/**
 * @author BNTang
 */
public class DaemonTestOne extends Thread {

    /**
     * 创建线程时, 设置线程名称
     */
    public DaemonTestOne(String threadName) {
        super(threadName);
    }

    @Override
    public void run() {
        int i = 0;
        while (!isInterrupted()) {
            i += 1;
            System.out.println("ThreadName = " + Thread.currentThread().getName() + "-" + i);
        }
        System.out.println("interrupt is = " + isInterrupted());
    }

    public static void main(String[] args) throws InterruptedException {
        DaemonTestOne myThread = new DaemonTestOne("MyThreadName");

        // 如果false, 创建的线程会一直执行
        // 如果为true, 创建的线程则会和main方法一起结束
        myThread.setDaemon(true);
        myThread.start();

        Thread.sleep(100);
    }
}

和主线程共存的, 只要主线程存在, 守护线程就一起存在, 主线程死亡, 守护线程也会死亡。

/**
 * @author BNTang
 */
public class DaemonTestTwo extends Thread {
    /**
     * 创建线程时, 设置线程名称
     */
    public DaemonTestTwo(String threadName) {
        super(threadName);
    }

    @Override
    public void run() {
        try {
            int i = 0;
            while (!isInterrupted()) {
                i += 1;
                System.out.println("ThreadName = " + Thread.currentThread().getName() + "-" + i);
            }
            System.out.println("interrupt is = " + isInterrupted());
        } finally {
            System.out.println("finally");
        }
    }

    public static void main(String[] args) throws InterruptedException {
        DaemonTestTwo myThread = new DaemonTestTwo("MyThreadName");

        // 如果false 会执行finally, 创建的线程会一直执行
        // 如果为true 不会执行finally, 创建的线程则会和main方法一起结束
        myThread.setDaemon(true);
        myThread.start();

        Thread.sleep(30);

        // 如果为true，是不会执行 finally，我这里调用了中断所以会执行
        myThread.interrupt();
    }
}

ThreadLocal

ThreadLocal 是什么

• ThreadLocal 是 线程本地变量，在每一个 Thread 中都维护者一个关联 ThreadLocal 的变量
• 意思是 ThreadLocal 中填充的变量属于当前线程，该变量对其他线程而言是隔离的
• ThreadLocal 为变量在每个线程中都创建了一个副本，那么每个线程可以访问自己内部的副本变量

ThreadLocal 怎么用

/**
 * @author BNTang
 **/
public class Demo01 {
    public static void main(String[] args) {
        ThreadLocal<String> local = new ThreadLocal<>();

        // 新建一个随机类
        Random random = new Random();

        IntStream.range(0, 5).forEach(a -> new Thread(() -> {

            // 为每一个线程设置相应的 local 值，每一个线程都有各自的local值
            local.set("第" + a + "个线程，随机数" + random.nextInt(10));

            System.out.println(local.get());

            // 设置了一个休眠时间，就是为了另外一个线程也能够及时的读取当前的 local 值。
            SleepTools.sleepSecond(1);
        }).start());
    }
}

ThreadLocal 源码分析

set 方法

首先获取到了当前线程 t，然后调用 getMap 获取 ThreadLocalMap 如果 map 存在，则将当前线程对象 t 作为 key，要存储的对象作为 value 存到 map 里面去。如果该 Map 不存在，则初始化一个。

get 方法