【Java进阶】多线程&高并发（一）＜线程概述＞

一、线程相关概念

1. 进程

• 进程（process）是计算机中的程序关于某数据集合上的一次运行活动，是操作系统进行资源分配与调度的基本单位
• 进程可以简单理解为正在操作系统中运行的一个程序

2. 线程

• 线程（thread）是进程的一个执行单元
• 一个线程就是进程中一个单一顺序的控制流，是进程的一个执行分支

3. 进程和线程区别

• 进程是线程的容器，一个进程至少有一个线程，一个进程中可以有多个线程
• 在操作系统中是以进程为单位分配资源的，如：虚拟存储空间、文件描述符等
• 每个线程都有各自的线程栈，自己的寄存器环境，自己的线程本地存储

4. 主线程和子线程

• JVM启动时会创建一个主线程，该主线程负责执行main()方法，主线程就是运行main()方法的线程
• Java中的线程不是孤立的，线程之间存在一些联系，如果在A线程中创建了B线程，称B线程是A线程的子线程，相应的A线程就是B线程的父线程

5. 串行、并发和并行

• 并发可以提高事物的处理效率，即一段时间内可以处理或者完成更多的事情
• 并行是一种更为严格、理想的并发
• 从硬件角度来说，如果单核CPU，一个处理器一次只能执行一个线程的情况下，处理器可以使用时间片轮转技术，可以让CPU快速的在各个线程之间进行切换，对于用户来说，感觉是三个线程在同时执行。如果是多核心CPU，可以为不同的线程分配不同的CPU内核

二、线程的创建与启动

1. 介绍

• 在Java中，创建一个线程就是创建一个Thread类（子类）的对象（实例）
• Thread类有两个常用的构造方法：Thread()和Thread(Runnable)，对应的创建线程的两种方式，这两种创建线程的方式没有本质的区别
  ① 定义Thread类的子类
  ② 定义一个Runnable接口的实现类

2. 继承Thread类

• 基本使用

package Thread;

/**
 * 继承Thread类
 *
 * @author swaggyhang
 * @create 2023-06-14 19:51
 */
public class ExtendsThreadDemo {
    public static void main(String[] args) {
        System.out.println("JVM启动main线程，main线程执行main()方法");
        // 3 创建子线程对象
        MyThread thread = new MyThread();

        // 4 启动线程
        thread.start();

        /**
         * 1）调用线程的start()方法来启动线程
         * 2）启动线程的实质就是请求JVM运行相应的程序，这个线程具体在什么时候运行，由线程调度器（Scheduler）决定
         * 3）start()方法调用结束并不意味着子线程运行开始
         * 4）新开启的线程会执行run()方法
         * 5）如果开启了多个线程，start()方法调用的顺序并不一定就是线程启动的顺序
         * 6）多线程运行结果与代码执行顺序或调用顺序无关
         */
        System.out.println("main线程后面其他的代码...");
    }
}

// 1 定义类继承Thread
class MyThread extends Thread {

    // 2 重写Thread类的run()方法
    // run()方法体中的代码就是子线程要执行的任务
    @Override
    public void run() {
        System.out.println("这是子线程打印的内容");
    }
}

• 多线程运行结果是随机的

package Thread;

/**
 * 多线程运行结果是随机的
 *
 * @author swaggyhang
 * @create 2023-06-14 20:21
 */
public class ThreadRandomDemo {
    public static void main(String[] args) {
        MyThread2 thread2 = new MyThread2();
        thread2.start();    // 开启子线程

        // 当前是main线程
        try {
            for (int i = 0; i < 10; i++) {
                System.out.println("main--:" + i);
                int time = (int) (Math.random() * 1000);
                Thread.sleep(time); // 线程睡眠，单位是毫秒
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class MyThread2 extends Thread {
    @Override
    public void run() {
        try {
            for (int i = 0; i < 10; i++) {
                System.out.println("sub thread:" + i);
                int time = (int) (Math.random() * 1000);
                Thread.sleep(time); // 线程睡眠，单位是毫秒
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

3. 实现Runnable接口

package Thread;

/**
 * 当线程类以及有父类了，就不能用继承Thread类来创建线程，可以使用实现Runnable接口来创建线程
 *
 * @author swaggyhang
 * @create 2023-06-14 20:56
 */
public class ImplementsRunnableDemo {
    public static void main(String[] args) {
        // 3 创建Runnable接口的实现类对象
        MyRunnable runnable = new MyRunnable();
        // 4 创建线程对象
        Thread thread = new Thread(runnable);
        // 5 开启线程
        thread.start();

        // 当前是main线程
        for (int i = 0; i < 10000; i++) {
            System.out.println("main ==> " + i);
        }

        // 有时调用Thread(Runnable)构造方法时，实参也会传递匿名内部类对象
        Thread thread2 = new Thread(new Runnable() {
            @Override
            public void run() {
                for (int i = 0; i < 10000; i++) {
                    System.out.println("sub ----------------> " + i);
                }
            }
        });
        thread2.start();
    }
}

// 1 定义类实现Runnable接口
class MyRunnable implements Runnable {
    // 2 重写Runnable接口中的抽象方法run()，run()方法就是子线程要执行的代码
    @Override
    public void run() {
        for (int i = 0; i < 10000; i++) {
            System.out.println("sub thread --> " + i);
        }
    }
}

三、线程的常用方法

1. currentThread()方法

• Thread.currentThread()方法可以获得当前线程
• Java中的任何一段代码都是执行在某个线程当中的，执行当前代码的线程就是当前线程
• 同一段代码可能被不同的线程执行，因此当前线程是相对的
• Thread.currentThread()方法的返回值是在代码实际运行时候的线程对象
• 基础使用

package Thread;

/**
 * @author swaggyhang
 * @create 2023-06-14 21:15
 */
public class CurrentThreadDemo {
    public static void main(String[] args) {
        System.out.println("main方法中打印当前线程：" + Thread.currentThread().getName());

        // 创建子线程，调用SubThread1()构造方法，在main线程中调用的，因此构造方法中的当前线程就是main线程
        SubThread1 t1 = new SubThread1();
        t1.start(); // 启动子线程，子线程会调用run()方法，因此run()方法中的当前线程就是Thread-0子线程

        t1.run();   // 在main()方法中直接调用run()方法，没有开启新的线程，因此在run()方法中的当前线程是main线程
    }
}

class SubThread1 extends Thread {
    public SubThread1() {
        System.out.println("构造方法打印当前线程名称：" + Thread.currentThread().getName());
    }

    @Override
    public void run() {
        System.out.println("run方法打印当前线程名称：" + Thread.currentThread().getName());
    }
}

• 复杂案例

package Thread;

/**
 * @author swaggyhang
 * @create 2023-06-14 21:24
 */
public class CurrentThreadComplexDemo {
    public static void main(String[] args) throws InterruptedException {
        // 创建子线程对象
        SubThread2 t2 = new SubThread2();
        t2.setName("t2");   // 设置线程名称
        t2.start();

        Thread.sleep(500);  // main线程睡眠500毫秒，保证t2线程已经启动

        // Thread(Runnable)构造方法形参是Runnable接口，调用时传递的实参是该接口的实现类对象
        Thread t3 = new Thread(t2);
        t3.start();
    }
}

class SubThread2 extends Thread {
    public SubThread2() {
        System.out.println("构造方法中,Thread.currentThread().getName():" + Thread.currentThread().getName());
        System.out.println("构造方法中,this.getName():" + this.getName());
    }

    @Override
    public void run() {
        System.out.println("run方法中,Thread.currentThread().getName():" + Thread.currentThread().getName());
        System.out.println("run方法中,this.getName():" + this.getName());
    }
}

2. setName()/getName()方法

• thread.setName(线程名称)，设置线程名称
• thread.getName()返回线程名称
• 通过设置线程名称，有助于程序调试，提高程序的可读性，建议为每个线程都设置一个能够体现线程功能的名称

3. isAlive()方法

• thread.isAlive()判断当前线程是否处于活动状态
• 活动状态就是线程已经启动并且尚未终止

package Thread;

/**
 * 线程的活动状态
 *
 * @author swaggyhang
 * @create 2023-06-14 21:51
 */
public class IsAliveDemo {
    public static void main(String[] args) {
        SubThread3 t3 = new SubThread3();
        System.out.println("begin==，isAlive = " + t3.isAlive());    // false，在启动线程之前
        t3.start();
        System.out.println("end==，isAlive = " + t3.isAlive());  // 结果不一定，打印这一行时，如果t3线程还没结束就返回true，结束了就返回false
    }
}

class SubThread3 extends Thread {
    @Override
    public void run() {
        System.out.println("run方法，isAlive = " + this.isAlive());
    }
}

四、线程的生命周期

五、多线程编程的优势与存在的风险