Java多线程基础

Java多线程基础

一、什么是进程与线程？

进程

当我们双击运行电脑程序的时候，操作系统就会为其创建一个进程，这个进程就是来维护这个程序在电脑内存上运行的状态（从双击运行到点击关闭期间）线程是操作系统分配资源的基本单位

为什么要有进程

进程的出现就是因为我们的单核CPU发展到了瓶颈了，这时就出现了多核CPU，而进程也是为了更加充分的利用多核CPU的资源**（并行+并发）**，但是每个进程的创建与销毁，消耗了太多的资源，所以就以进程为基础，剥离出来了线程的概念

并行与并发

并行：一个CPU以时间片轮转的方式依次执行每个线程，某一段时间宏观来看，就像是多个线程一同执行一样

并发：多个线程在同一个时间点同时运行

线程

线程是从进程中剥离出来的，因此，一个进程是可以剥离出多个线程的，而进程是操作系统分配资源的基本单位，所以这多个线程就会公用该进程的资源，因此线程的创建与销毁是比进程的消耗更小了，从而提升了并发编程的效率

虽然线程相对于进程的消耗已经减少了许多，可是在有的场景下，就是需要频繁创建与销毁线程，这时线程的消耗也起来了，所以 Java 进入了 线程池的概念

线程是操作系统随机调度的基本单位

主要应用场景

1. 计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现
2. I/O 密集型，多线程可以充分利用CPU，在执行IO操作的时候（需要等待），让线程去干点别的事情

二、线程和进程的区别【重点】

1. 进程包含线程，线程是在进程内部的
2. 每个进程都有自己独立的虚拟地址空间，也有自己独立的文件描述符表；同一个进程的多个线程之间，则共用这一份虚拟地址空间和文件描述符表
3. 进程是操作系统中资源分配的基本单位。线程是操作系统中调度执行的基本单位
4. 多个进程同时运行时，如果一个进程挂了，一般不会影响别的进程；而同一个进程里面的多个线程之间，如果一个线程挂了，很可能把整个进程带走了，当前进程的其他线程也就没了

三、线程的创建方式【重点】

1. 继承Thread类

class MyThread extends Thread {
    @Override
    public void run() {
        while (true) {
            System.out.println("Hello thread");
        }
    }
}

public class Demo1 {
    public static void main(String[] args) {
        Thread thread = new MyThread();
        thread.start();

        while (true) {
            System.out.println("Hello main");
        }
    }
    
    // 直接匿名内部类也可以
    public static void main(String[] args) {
        Thread thread = new Thread(){
            @Override
            public void run() {
                System.out.println("hello thread");
            }
        };

        thread.start();

        System.out.println("hello main");
    }
}

2. 实现Runnable接口

class MyRunable implements Runnable {

    @Override
    public void run() {
        System.out.println("hello thread");
    }
}

public class Demo2 {
    public static void main(String[] args) {
        Thread thread = new Thread(new MyRunable());
        thread.start();

        System.out.println("hello main");
    }
}

3. lambda 表达式

public static void main(String[] args) {
        Thread thread = new Thread(()->{
            System.out.println("hello thread");
        });

        thread.start();

        System.out.println("hello main");
    }

四、Thread的常见属性

属性	获取方法
ID	getId()
名称	getName()
状态	getState()
优先级	getPriority()
是否有后台线程	isDaemon()
是否存活	isAlive()
是否被中断	isInterrupted()

👁‍🗨️说明：

ID：是线程的唯一标识，多个线程不能重复 （这里能获取的就是JVM中的ID标识，而操作系统内部也有一个ID）
名称：是线程的名称（方便程序员调试的时候查看）
状态：表示线程所处的情况（JVM中的状态，一共6种，往下看）
优先级：理论来说，优先级高的线程优先被调度到（它是一个数值来表示的，数值越小，优先级越高）
后台线程：JVM会在一个进程的所有非后台线程结束后，才会结束运行
是否存活：简单理解为run方法是否运行结束
线程中断：是否要提前截至 run 方法

线程中断

两种中断机制：1. 自己定义一个 flag 标志位，来控制；2. Thread提供的一个静态方法

自己定义一个标志位

// 自定义标志位来控制线程是否结束
public class Demo7 {
    // 用一个布尔变量表示线程是否要结束
    private static boolean isQuit = false;

    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(() -> {
            while (!isQuit) {
                System.out.println("线程运行中……");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("线程执行结束");
        });

        t.start();

        // 5秒钟后，中断线程
        Thread.sleep(5000);
        isQuit = true;
    }
}

Thread类提供的静态方法

调用 interrupt() 来实现中断，会产生两种情况：

1. 若当前线程处于非堵塞状态，那么程序就会修改内置的标志位
2. 若当前线程处于堵塞状态，inerrupt()的调用就会让线程中的sleep抛异常，然后被catch捕获，然后我们自己决定退不退出

public class Demo8 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            // Thread.currentThread() 获取当前线程的引用
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("线程运行中");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
//                    e.printStackTrace();

                    // [1] 立即退出
//                    break;

                    // [2] 稍后退出
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException ex) {
//                        ex.printStackTrace();
                        // 处理退出前的任务
                        break;
                    }
                }
            }
            System.out.println("线程结束");
        });

        t.start();

        // 调用 interrupt() 会产生两种效果：
        // 1. 若当前线程处于非堵塞状态，那么程序就会修改内置的标志位
        // 2. 若当前线程处于堵塞状态，interrupt()的调用就会让线程中的sleep抛异常，然后被catch捕获，然后我们自己决定退不退出
        t.interrupt();
    }
}

线程的状态

1. NEW：线程创建好了，但是还未执行 start 方法，也就是还没把该线程加到 PCB 队列中，参与调度
2. TERMINATED：run 方法体执行完毕，但是程序还没结束（thread 变量还未销毁）
3. RUNNABLE：调用了 start 方法后的状态，可能在 CPU上运行，也可能在就绪队列中等待调度上CPU
4. BLOCKED：当前线程在等待锁，导致阻塞
5. WAITING：当前线程在等待唤醒，导致阻塞（wait 操作）
6. TIMED_WARNING：当前线程在一定时间内阻塞（sleep，join操作）