线程概述

进程/线程

• 进程是指操作系统中的一段程序, 它是一个正在执行的程序实例, 具有独立的内存空间和系统资源, 所以进程之间资源不共享, 如文件, 网络端口等, 在计算机运行时, 一般是先创建进程, 后创建线程, 一个进程通常可以包含多个线程
• 线程是指的是进程中的一个执行单元, 是进程的一部分, 负责在进程中执行代码, 每一个线程都有自己的栈和程序计数器, 并且可以共享进程的资源, 多个线程可以在同一个时刻执行不同的操作, 从而提高程序的执行效率, 线程与线程之间的资源并不是完全共享的, 下面会详细介绍…

---

大白话总结:

• 一个应用程序就是一个进程
• 一个进程里面有多个线程执行任务

多线程的作用

最重要的就是提高处理问题的效率, 能够使CPU在处理一个任务时同时处理多个线程, 这样可以充分利用CPU的资源, 提高CPU的资源利用率

JVM关于线程资源的规范

我们用下面的一张图来说明

在同一个进程的多个线程之间, Heap(堆), Method Area(方法区)资源是共享的, Java Virtual Machine Stack(Java虚拟机栈), Native Method Stack(本地方法栈), The pc Register(程序计数器)这些都是不能够共享的

所以就存在线程安全的问题
比如对于变量来说, 局部变量存在Java虚拟机栈, 所以不存在线程安全问题, 但是实例变量, 静态变量都存在于堆中, 就会存在线程安全的问题

关于Java程序的运行原理

• 当JVM启动的时候, JVM会自动开启一个主线程(main-thread), 然后去调用main方法
  所以main方法都是在主线程中执行的
• 除了主线程之外, 还会启动一个垃圾回收线程(GC), 因此启动JVM, 至少启动了两个线程
• 除上述线程之外, 程序员可以手动创建其他的线程并启动

---

并发与并行

早期的人们使用的单核的CPU, 那是不是不能同时运行多个程序呢? 答案是否定的, 下面的关于并发与并行就可以解释这个问题

并发(concurrency)

• 在使用单核心CPU时候, 微观层面一个时间点只能执行一个指令, 但多个指令被快速的轮换执行，使得在宏观上具有多个指令同时执行的效果，但在微观上并不是同时执行的，只是把时间分成若干端，使多个指令快速交替的执行

下面的这张图就可以很好的说明这个问题

横轴对应的是时间, 纵轴对应的是ABC三个程序, 围观层面, 某一时间点只能执行一个程序, 但是通过CPU高速的在ABC三个程序中进行调度切换, 让我们宏观上看起来是三个程序同时执行的, 这种情况就是并发

并行(parallellism)

• 这种情况针对的就是多核心CPU的情况, 此时在一个时间点, 微观层面上也可以通过多个核心同时多个程序来达到真正意义上的"同时执行"
  

并发编程与并行编程

• 在多核心CPU资源紧缺(或者是单核心CPU)的前提下, 如果开启了多个线程, 但是只有一个CPU核心可以提供资源, 那么这些线程就会抢夺CPU的时间片, 竞争执行机会, 这就是通过 并发 的方式实现多线程
• 当多核心CPU资源比较充足的情况下, 此时有多个CPU核心可以来提供资源, 此时一个进程中的线程就会被分配到多个CPU核心上同时执行, 这就是通过 并行 的方式实现多线程
• 不管并发还是并行，都提高了程序对CPU资源的利用率，最大限度地利用CPU资源，而我们使用多线程的目的就是为了提高CPU资源的利用率

---

那么Java实现多线程的方式是并发还是并行呢?

• 至于Java多线程实现的是并发还是并行？上面所说，所写多线程可能被分配到一个CPU内核中执行，也可能被分配到不同CPU执行，分配过程是操作系统所为，不可人为控制。所以，如果有人问我我所写的多线程是并发还是并行的？我会说，都有可能

线程的调度策略

存在线程调度的原因是因为, 当多个线程被分配到同一个CPU核心执行的时候, 此时这些程序就会抢夺CPU的时间片从而或者执行权, 所以就存在执行的先后问题

分时调度模型

• 所有线程轮流使用CPU的执行权, 并且平均每个线程的占用时间, 也就是绝对平均

抢占式调度模型

• 让优先级高的线程以较大的概率优先获得CPU的执行权, 如果线程的优先级相同, 那么就会随机选择一个线程获得CPU的执行权, 而Java采用的就是抢占式调度模型

创建线程

线程类分析入门

这个是JDK17帮助文档的链接
JDK17帮助文档
通过API文档, 我们可以查询到我们需要的一些信息内容, 从而完成编程(这里不推荐查看中文的帮助文档)

---

构造方法

构造方法可以通过传入一个字符串然后指定该线程的名称

---

static Thread currentThread()

这是一个静态方法, 通过这个方法可以获取到当前线程的Thread信息, 其实有点类似于之前学的this

---

void setName(String name)

这是一个实例方法, 通过一个线程的引用调用之后可以设置当前线程的名称(其实每一个线程都有一个默认的名称)

---

String getName()

这是一个实例方法, 作用就是调用之后可以获得当前线程的名称

---

实现线程的第一种方式

执行逻辑如下

• 创建一个类继承Thread(java.lang)包下的, 默认导入)类
• 重写Thread中的run()方法(这个run()相当于每个线程的main函数)
• 创建这个类的对象, 然后调用start()方法, 开启线程

---

我们给一个代码的案例测试一下

package thread_demo.thread_demo01;

public class Thread01 {
    public static void main(String[] args) {
        // 当执行main函数的时候, 系统自动的就开启了两个线程
        Thread t = new MyThread();
        t.start();

        // 主线程的内容
        for(int i = 0; i < 100; i++){
            System.out.println(Thread.currentThread().getName() + "---->" + i);
        }
    }
}

/**
 * 创建线程的第一种方式是创建一个类继承Thread(所以这个类其实也就是一个线程)
 * 1. 创建一个类继承Thread这个线程类(所以此时这就是一个线程)
 * 2. 重写run方法(这就相当于每一个线程运行的入口)
 * 3. new一个线程对象然后调用start()方法启动一个线程
 */
class MyThread extends Thread {
    @Override
    public void run() {
        for(int i = 0; i < 100; i++){
            System.out.println(Thread.currentThread().getName() + "---->" + i);
        }
    }
}

执行结果如下

两个线程会无规则的交替执行
初学者好多不理解这个代码的执行逻辑, 首先我们在main中创建了一个线程对象, start()的作用就是开启一个线程, 然后就弹栈了, 此时JVM中就存在了两个线程同时执行(不含GC), 所有就会出现交替执行的情况

实现线程的第二种方式

执行逻辑如下

• 创建一个类实现Runnable接口
• 重写其中的run()方法
• 创建这个类的对象(匿名的也可以), start()开启一个线程

---

给一个代码案例测试一下

package thread_demo.thread_demo02;

public class Thread02 {
    public static void main(String[] args) {
        // 直接new一个对象调用创建一个t线程
        Runnable r = new MyThread();
        Thread t = new Thread(r, "test1");
        // 开启t线程
        t.start();

        // 利用匿名内部类的方式创建一个线程对象
        Thread t1 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(Thread.currentThread().getName() + "--->" + i);
                }
            }
        }, "test2");
        // 开启t1线程
        t1.start();

        // 直接就不接收变量直接开启一个线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 100; i++) {
                    System.out.println(Thread.currentThread().getName() + "--->" + i);
                }
            }
        }, "test3").start();

        // 最后在操作一下主线程
        Thread mainThread = Thread.currentThread();
        mainThread.setName("main");
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

/**
 * 创建线程的第二种方式是定义一个类去实现Runnable接口, 我们推荐使用这种方式开启多线程
 * 1. 定义一个类实现Runnable接口
 * 2. 重写run方法
 * 3. Thread t = new Thread(传入这个类的对象)
 * 4. t.start() 去开启一个线程
 */
class MyThread implements Runnable{
    @Override
    public void run() {
        for(int i = 0; i < 100; i++){
            System.out.println(Thread.currentThread().getName() + "--->" + i);
        }
    }
}

执行结果也是多个线程交替执行, 原理和第一种是一致的

线程的生命周期

线程的生命周期概述

线程的生命周期主要就是指的一个线程在不同时期的状态情况, 大致可以分

• 6种(JDK层面)
• 7种(我们平时常说的)

首先我们从JDK层面分析一下为什么是6种
我们查看一下帮助文档找到Thread.State这个枚举类型

• NEW : 新建状态, 也就是执行start()之前的状态
• RUNNABLE : 可运行状态, 这个状态分为两个子状态
  就绪状态 和 运行状态
• WAITING : 等待状态, 不限时间(比如等待用户输入)
• TIMED_WAITING : 超时等待状态, 限制时间(比如Thread.sleep(毫秒)
• BLOCKED : 阻塞状态, 比如遇到了一些关于锁的操作
• TERMINATED : 时亡状态, run()方法结束

线程生命周期间的关系(含UML图)

下面我们尝试绘制一个UML来描述一下各个状态之间的关系

图上说明的十分的详细了…, 我们再阐述一下

• 首先线程处于一个NEW的新建状态, 然后通过start()创建一个线程, 此时线程处于RUNNABLE(就绪状态)
• 位于RUNNABLE(就绪状态)的线程拥有抢夺CPU时间片的能力, 当抢夺到了CPU时间片之后, 线程的run()方法就开始执行, 此时线程处于RUNNABLE(运行状态), 当抢夺到的CPU时间片用完了之后, 线程会再次进入到RUNNABLE(就绪状态), 下次执行时会接着上一次的执行, 这个过程中靠的是CPU的调度机制
• 当程序在RUNNABLE(运行状态)遇到Thread.sleep(毫秒)类似的间隔的时候, 会进入到TIMED_WAITING超时等待状态, 此时会返还先前抢到的CPU时间片, 所有的等待休眠期度过之后, 会进入到RUNNABLE(就绪状态)等待下一次抢夺CPU时间片
• 当程序在RUNNABLE(运行状态)遇到例如接收到需要等待用户输入的指令的时候, 就会进入到WAITING等待状态, 这个等待状态是没有时间的限制的(比如接收到输入为止)
• 当run()方法彻底执行结束之后, 就会触发到TERMINATED状态…