Java-多线程

基本概念

程序和进程的概念

• 程序 - 数据结构 + 算法，主要指存放在硬盘上的可执行文件。
• 进程 - 主要指运行在内存中的可执行文件。
• 目前主流的操作系统都支持多进程，为了让操作系统同时可以执行多个任务，但进程是重量级的，也就是新建一个进程会消耗CPU和内存空间等系统资源，因此进程的数量比较局限。

线程的概念

• 为了解决上述问题就提岀线程的概念，线程就是进程内部的程序流，也就是说操作系统内部支持多进程的，而每个进程的内部又是支持多线程的，线程是轻量的，新建线程会共享所在进程的系统资源，因此目前主流的开发都是采用多线程。
• 多线程是采用时间片轮转法来保证多个线程的并发执行，所谓并发就是指宏观并行微观串行的机制。

线程的创建

Thread类的概念

• java.lang.Thread 类代表线程，任何线程对象都是 Thread类(子类)的实例。
• Thread 类是线程的模板，封装了复杂的线程开启等操作，封装了操作系统的差异性。

创建方式

1. 自定义类继承 Thread 类并重写 run 方法，然后创建该类的对象调用 start 方法
2. 自定义类实现 Runnable 接口并重写 run 方法，创建该类的对象作为实参来构造 Thread 类型的对象，然后使用Thread 类型的对象调用 start 方法。

相关的方法

方法声明	功能介绍
Thread()	使用无参的方式构造对象
Thread(String name)	根据参数指定的名称来构造对象
Thread(Runnable target)	根据参数指定的引用来构造对象，其中 Runnable 是个接口类型
Thread(Runnable target， String name)	根据参数指定引用和名称来构造对象
void run()	若使用 Runnable引用构造了线程对象，调用该方法时最终调用接口中的版本 若没有使用 Runnable引用构造线程对象，调用该方法时则啥也不做
void start()	用于启动线程，Java虚拟机会自动调用该线程的run方法

执行流程

• 执行main方法的线程叫做主线程，执行 run 方法的线程叫做新线程 / 子线程。
• main方法是程序的入口，对于 start 方法之前的代码来说，由主线程执行一次，当 start 方法调用成功后线程的数由 1 个变成了 2 个，新启动的线程去执行 run 方法的代码，主线程继续向下执行，两个线程各自独立运行互不影响。
• 当 run 方法执行完毕后子线程结束，当 main 方法执行完毕后主线程结束。
• 两个线程执行没有明确的先后执行次序，由操作系统调度算法来决定。

线程的创建方式

方式一：继承 Thread 类

public class SubThread extends Thread {
    @Override
    public void run() {
        for (int i = 1; i < 20; i++) {
            System.out.println("SubThread 中的 i = " + i);
        }
    }
}

public static void main(String[] args) {
    // 创建对象指向 Thread 类型的引用
    Thread subThread = new SubThread();
    // 启动线程 JVM 虚拟机会自动调用 run 方法
    // 不能直接调用 run 方法
    subThread.start();

    for (int i = 1; i < 20; i++) {
        System.out.println("main 中的 i = " + i);
    }
}

结果

主线程和多线程交叉运行，互不影响

方式二：实现 Runnable 接口

public class SubThreadRun implements Runnable {	
    @Override
    public void run() {
        for (int i = 1; i < 20; i++) {
            System.out.println("SubThreadRun 中的 i = " + i);
        }
    }
}

public static void main(String[] args) {
    // 1. 创建自定义类型的对象，也就是实现 Runnable 接口类的对象
    SubThreadRun subThreadRun = new SubThreadRun();
    // 2. 使用对象作为参数构造 Thread 对象
    Thread thread = new Thread(subThreadRun);
    // 3. 使用 Thread 类型引用调用 start() 方法
    // 若使用 Runnable 引用构造了线程对象，调用该方法(run)时最终调用接口中的版本
    thread.start();

    for (int i = 1; i < 20; i++) {
        System.out.println("SubThread 中的 i = " + i);
    }
}

方式的比较

• 继承 Thread类的方式代码简单，但是若该类继承 Thread类后则无法继承其它类，而实现Runnable接口的方式代码复杂，但不影响该类继承其它类以及实现其它接口，因此以后的开发中推荐使用第二种方式。

匿名内部类的方式

• 使用匿名内部类的方式来创建和启动线程。

public class SubThreadNoName {

    public static void main(String[] args) {

        // 继承加匿名内部类的方式创建并启动线程
        Thread tr1 = new Thread() {
            @Override
            public void run() {
                System.out.println("我是继承加匿名内部类的方式创建并启动线程");
            }
        };
        tr1.start();

        // 实现接口加匿名内部类的方式启动并创建的线程
        Runnable ra = new Runnable() {
            @Override
            public void run() {
                System.out.println("方式一：我是实现接口加匿名内部类的方式启动并创建的线程");
            }
        };
        Thread tr2 = new Thread(ra);
        tr2.start();

        Thread tr3 = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("方式二：我是实现接口加匿名内部类的方式启动并创建的线程");
            }
        });
        tr3.start();

        // lambda 表达式
        Thread tr4 = new Thread(() -> {
            System.out.println("方式三：我是实现接口加匿名内部类的方式启动并创建的线程");
        });
        tr4.start();
    }
}

线程的生命周期

• 新建状态 - 使用 new 关键字创建之后进入的状态，此时线程并没有开始执行。
• 就绪状态 - 调用 start 方法后进入的状态，此时程还是没有开始执行。
• 运行状态 - 使用线程调度器调用该线程后进入的状态，此时线程开始执行，当线程的时间片执行完毕后任务没有完成时回到就绪状态。
• 消亡状态 - 当线程的任务执行完成后进入的状态，此时线程已经终止。
• 阻塞状态 - 当线程执行的过程中发生了阻塞事件进入的状态，如：sleep方法。
  阻塞状态解除后进入就绪状态。

线程的编号和名称

方法声明	功能介绍
long getId	获取调用对象所表示线程的编号
String getName()	获取调用对象所表示线程的名称
void setName(String name)	设置/修改线程的名称为参数指定的数值
static Thread currentThread()	获取当前正在执行线程的引用

• 继承的方式
  

• 实现接口的方式
  

常用方法

方法声明	功能介绍
static void yield()	当前线程让出处理器(离开 Running状态),使当前线程进入 Runnable状态等待
static void sleep(times)	使当前线程从 Running 放弃处理器进入 Block 状态休眠 times毫秒,再返回到Runnable如果其他线程打断当前线程的 Block(sleep)就会发生InterruptedException
int getPriority()	获取线程的优先级
void setPriority(int newPriority)	修改线程的优先级。 优先级越高的线程不一定先执行,但该线程获取到时间片的机会会更多一些
void join()	等待该线程终止
void join(long millis)	等待参数指定的毫秒数
boolean isDaemono	用于判断是否为守护线程
setDaemon(boolean on)	用于设置线程为守护线程

sleep 方式的使用

import java.text.SimpleDateFormat;
import java.util.Date;

public class ThreadTest extends Thread {
    private boolean flag = true;

    @Override
    public void run() {
        while (flag) {
            // 时间对象
            Date date = new Date();
            // 格式化时间
            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            System.out.println(sdf.format(date));
            try {
                sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        ThreadTest tr = new ThreadTest();
        tr.start();
        try {
            sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 停止线程
        // tr.stop(); // 已过时不推荐使用
        tr.flag = false;
    }
}

线程的管理

修改线程的优先级。优先级越高的线程不一定先执行,但该线程获取到时间片的机会会更多一些

![image](https://img2020.cnblogs.com/blog/2354934/202109/2354934-20210909190301006-11927860.png)

线程的等待

守护进程