当前位置：首页 > article >正文

【Java多线程】：理解线程创建、特性及后台进程

article 2024/11/5 20:13:47

📃个人主页：island1314

⛺️ 欢迎关注：👍点赞 👂🏽留言 😍收藏 💞 💞 💞

一、背景 -- 进程与线程🚀

🔥 多线程是提升程序性能非常重要的一种方式，也是Java编程中的一项重要技术。在程序设计中，多线程就是指一个应用程序中有多条并发执行的线索，每条线索都被称作一个线程，它们会交替执行，彼此可以通信。

🥝 1. 进程

🌈 进程（process）是计算机中程序的一次运行活动，是系统进行资源分配和调度的基本单位，是操作系统结构的基础。

注意：虽然进程在程序执行时产生，但进程并不是程序

程序是“死”的，进程是“活”的
程序是指编译好的二进制文件，它存放在磁盘上，不占用系统资源，是具体的
而进程存在于内存中，占用系统资源，是抽象的。当一次程序执行结束时，进程随之消失，进程所用的资源被系统回收

对计算机用户而言，计算机似乎能够同时执行多个进程，如听音乐、玩游戏、语音聊天等，都能在同一台计算机上同时进行。但实际上，一个单核的CPU同一时刻只能处理一个进程，用户之所以认为同时会有多个进程在运行，是因为计算机系统采用了多道程序设计技术

多道程序设计技术（了解）

所谓多道程序设计，是指计算机允许多个相互独立的程序同时进入内存,在内存的管理控制之下，相互之间穿插运行。多道程序设计必须有硬件基础作为保障
采用多道程序设计的系统，会将CPU的周期划分为长度相同的时间片，在每个CPU时间片内只处理一个进程，也就是说，在多个时间片内，系统会让多个进程分时使用CPU

假如现在内存中只有3个进程——A、B、C，那么CPU时间片的分配情况大致如下

🐸 虽然在同一个时间片中，CPU只能处理一个进程，但CPU划分的时间片是非常微小的，且CPU运行速度极快(1秒可执行约10亿条指令）

因此，在宏观上，可以认为计算机能并发执行多个程序、处理多个进程。

🦌 进程对 CPU 的使用权是由操作系统内核分配的，操作系统内核必须知道内存中有多少个进程，并且知道此时正在使用CPU的进程，这就要求内核必须能够区分进程，并可获取进程的相关属性。

🥝 2. 线程

🔥 通过上面可以知道，每个运行的程序都是一个进程，在一个进程中还可以有多个执行单元同时运行，这些执行单元可以看作程序执行的线程（thread)。每一个进程中都至少存在一个线程。

例如，当一个Java程序启动时，就会产生一个进程，该进程默认创建一个线程，这个线程会运行main(）方法中的代码。

单线程与多线程

如果代码都是按照调用顺序依次往下执行的，没有出现两段程序代码交替运行的效果，这样的程序称作单线程程序
如果希望程序中实现多段程序代码交替运行的效果，则需要创建多个线程，即多线程程序

所谓多线程是指一个进程在执行过程中可以产生多个线程，这些线程在运行时是相互独立的，它可以并发执行的。过程如下：

💢 注意：多条线程看起来是同时执行的；其实不然，它们和进程一样，也是由CPU轮流执行的，只不过CPU运行速度很快，因此给人同时执行的感觉。

🥝 3. 进程 VS 线程

3.1 线程的优点

创建一个新线程的代价要比创建一个新进程小得多
与进程之间的切换相比，线程之间的切换需要操作系统做的工作要少很多
线程占用的资源要比进程少很多
能充分利用多处理器的可并行数量
在等待慢速I/O操作结束的同时，程序可执行其他的计算任务
计算密集型应用，为了能在多处理器系统上运行，将计算分解到多个线程中实现
I/O密集型应用，为了提高性能，将I/O操作重叠。线程可以同时等待不同的I/O操作

3.2 进程与线程的区别

进程是系统进行资源分配和调度的一个独立单位，线程是程序执行的最小单位
进程有自己的内存地址空间，线程只独享指令流执行的必要资源，如：寄存器和栈
由于同一进程的各线程间共享内存和文件资源，可以不通过内核进行直接通信
线程的创建、切换及终止效率更高

二、线程的创建 🖊

💢 Java 提供了 3 种多线程的创建方式：

继承 java.lang包中的 Thrad类，重写 Thrad类的 run() 方法，在run()方法中实现多线程代码。
实现 java.lang.Runnable 接口，在 run()方法中实现多线程代码。
实现 java.util.concurrent.Callable 接口，重写 call()方法，并使用Future接口获取

♻️1. 继承 Thread 类创建多线程

在学习多线程之前，我们先来看一个代码

class MyThread{
    public void run() {
        while(true) {
            System.out.println("MyThread类的 run（） 方法在运行");
        }
    }
}

public class thread_create {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.run();
        while(true) {
            System.out.println("main（）方法在运行");
        }
    }
}

显而易见，上面代码输出是个死循环，一直打印 MyThread类的 run（）方法在运行

⚜️如果我们想让上面代码中的两个while 循环中的语句能够并发执行，就需要去实现 多线程

为此Java 提供了线程类 Thread。通过继承Thread类类，并重写Thread类中的 run（)方法，便可实现多线程。
在 Thread类 中提供了 start() 方法用于启动新线程。
新线程启动后，Java虚拟机会自动调用 run(）方法；如果子类重写了run(）方法，便会执行子类中的 run(）方法

修改后的代码如下：

class MyThread extends Thread{
    public void run() {
        while(true) {
            System.out.println("MyThread类的 run（） 方法在运行");
        }
    }
}

public class thread_create {
    public static void main(String[] args) {
        MyThread myThread = new MyThread();
        myThread.start(); // 开启线程
        while(true) {
            System.out.println("main（）方法在运行");
        }
    }
}

运行如下：

由上图可知，两个循环中的语句都输出到控制台，说明实现了多线程。

为了使读者更好地理解单线程程序和多线程程序的执行过程，下面通过下图分析单线程和多线程的区别

从上图可以看出

单线程程序在运行时，会按照代码的调用顺序执行
而在多线程程序中，main() 方法和 MyThread 类的 run() 方法可以同时运行，互不影响。

♻️2. 实现 Runnable 接口创建多线程

🔥 上面通过继承Thread类实现了多线程，但是这种方式有一定的局限性。因为Java只支持单继承，一个类一旦继承了某个父类，就无法再继承 Thread类

例如，Student类继承了Person类,那么Student 类就无法再通过继承Thread类创建线程

🐸 为了克服这种弊端，Thread类提供了另一个构造方法 ---- Thread(Runnable target)

其中参数类型 Runnable 是一个接口，它只有一个 run()方法。
当通过 Thread(Runnable target) 构造方法创建线程对象时，只需为该方法传递一个实现了Runnable 接口的对象，这样，创建的线程将实现 Runnable 接口中的 run() 方法作为运行代码，而不需要调用 Thread 类中的 run() 方法。

如下：

class MyThread implements Runnable{
    public void run() {
        while(true) {
            System.out.println("MyThread类的 run（） 方法在运行");
        }
    }
}
public class thread_create {
    public static void main(String[] args) {
        MyThread myThread = new MyThread(); // 创建实例对象
        Thread thread = new Thread(myThread); // 创建线程对象
        thread.start(); // 开启线程
        while(true) {
            System.out.println("main（）方法在运行");
        }
    }
}

运行如下：

此时 main() 方法和 MyThread 类中的 run() 方法都被实现了，说明实现了多线程

♻️3. 实现 Callable 接口创建多线程

🔖 通过 Thread 类和 Runnable 接口实现多线程时，需要重写run(）方法，但是由于run(）方法没有返回值，无法从新线程中获取返回结果。为了解决这个问题，Java 提供了Callable接口来满足这种既能创建新线程又有返回值的需求。

通过实现 Callable接口的方式创建并启动线程的主要步骤如下：

创建 Callable接口的实现类，同时重写Callable接口的 call() 方法
创建 Callable接口的实现类对象
通过线程结果处理类 FutureTask的有参构造方法封装 Callable接口的实现类对象
调用参数为 FutureTask类对象的有参构造方法 Thread()创建Thread线程实例。
调用线程实例的 start(）方法启动线程。

// 定义实现 Callable 的实现类
class MyThread implements Callable<Object> {
    // 重写 call 方法
    public Object call() throws Exception {
        int i = 0;
        while (i++ < 3){
            System.out.println(Thread.currentThread().getName() + "的方法在运行");
        }
        return i;
    }
}


public class thread_create {
    public static void main(String[] args) throws InterruptedException,ExecutionException{
        MyThread myThread = new MyThread(); // 创建实例对象
        // 使用 FutureTask 封装
        FutureTask<Object> ft = new FutureTask<>(myThread);
        // 使用 Thread(Runnable target, string name) 构造方法创建线程对象
        Thread thread = new Thread(ft, "thread");

        thread.start(); // 启动线程
        // 通过FutureTask 对象的方法管理返回值
        System.out.println(Thread.currentThread().getName() + "的返回结果：" + ft.get());

        int i = 0;
        while(i++ < 3) {
            System.out.println("main（）方法在运行");
        }
    }
}

运行结果如下：

上面代码通过实现 Callable 接口的方式实现了多线程并且还有返回结果

🌙 Callable 接口方式实现的多线程是通过 FutureTask类来封装和管理返回结果的，FutureTask类的直接父接口是 RunnableFuture，从名称上可以看出 RunnableFuture 是 Runnable 和Future的结合体。

FutureTask 类的继承关系如下

由上图可以知道：FutureTask 的本质是 Runnable 接口和 Future 接口的实现类。其中 Future 接口用于管理线程返回结果，它共有 5 个方法如下：

方法声明	功能描述
boolean cancel (boolean mayInterruptIfRunning)	用于取消任务。参数 mayInterruptIfRunning 表示是否允许取消正在执行却没有执行完毕的任务。若参数设为 true，则表示可以取消正在执行的任务
boolean isCancelled ()	判断任务是否被成功取消
boolean isDone ()	判断任务是否已完成
V get()	用于获取执行结果。注意：这个方法会发生堵塞，一直等到任务执行完毕才返回执行结果
V get (long timeout, TimeUnit unit)	用于在指定时间内获取执行结果

♻️4. Thread 类与 Runnable 接口实现多线程对比

🌈多线程的实现方式有3种，其中Runnable 接口和 Callable 接口实现多线程的方式基本相同，主要区别就是Callable接口中的方法有返回值而 Runnable 接口中的方法没有返回值。

通过继承 Thread 类和实现 Runnable 接口实现多线程方式会有一定的区别

下面通过一个应用场景来分析说明：

假设售票厅有 2 个窗口可发售某日某次列车的 3 张车票。
这时，3 张车票可以看作共享资源；2 个售票窗口同时售票，可以看作 2 个线程同时运行。
为了更直观地显示窗口的售票情况，可以调用 Thread 类的 currentThread() 方法获取当前线程的实例对象，然后调用 getName() 方以获取线程的名称。

（1）首先通过继承 Thread 类的方式创建多线程来演示售票情景，如下：

class TicketWindow extends Thread{
    private int tickets = 3;
    public void run(){
        while (tickets > 0){
            Thread t = Thread.currentThread(); // 获取当前线程
            String t_name = t.getName(); // 获取当前线程名字
            System.out.println(t_name +  "正在发售第 " + tickets-- + " 张票");
        }
    }
}

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

运行结果如下：

从上图可以看出，每张票都被打印了 2 次。出现这个现象的原因是 2 个线程没有共享 3 张票，而是各自出售了 3 张票

在程序中创建了2 个 TicketWindow 对象，就等于创建了 2 个售票线程，每个线程中都有 3 张票，每个线程在独立地处理各自的资源。

需要注意的是：上面的每个线程都有自己的名字，主线程默认的名字是main，用户创建的第一个线程的名字默认为Thread-0，第二个线程的名字默认为Thread-1，以此类推。
由于现实中铁路系统的车票资源是共享的，因此上面的运行结果显然不合理

为了保证资源共享，在程序中只能创建一个售票对象，然后开启多个线程运行同一个售票对象的售票方法，简单来说，就是 2 个线程运行同一个售票程序

用Thread类创建多线程，无法保证多个线程对共享资源的正确操作
而Runnable接口可以保证多个线程对共享资源的正确访问。接下来，通过实现Runnable 接口的方式实现多线程的创建。

修改代码使用构造方法 Thread(Runnable target, String name) 在创建线程对象时指定线程名称

class TicketWindow implements Runnable{
    private int tickets = 3;
    public void run(){
        while (tickets > 0){
            Thread t = Thread.currentThread(); // 获取当前线程
            String t_name = t.getName(); // 获取当前线程名字
            System.out.println(t_name +  "正在发售第 " + tickets-- + " 张票");
        }
    }
}

public class thread_ticket {
    public static void main(String[] args) {
        TicketWindow tw = new TicketWindow();
        new Thread(tw, "窗口1").start();
        new Thread(tw, "窗口2").start();
    }
}

运行结果如下：

注意：Thread 类下也可以实现资源共享，还记得我们之前学的 static 全局共享嘛，我们可以给 ticket 票加上这个属性，就可以使所有窗口共享资源了，如下：

三、后台线程

🔥 在多线程中，主线程如果不等待子线程的返回结果，那么主线程与子线程没有先后顺序，有可能主线程先结束了，子线程还没结束。

在这样的情况下，虽然主线程结束了，但整个程序进程是不会结束的，因为子线程还在执行。

💧 有人可能会认为，当 main() 方法中创建并启动的 2 个新线程的代码执行完毕后，主线程也就随之结束了。然而，通过程序的运行结果可以看出，虽然主线程结束了，但整个Java程序却没有随之结束，仍然在执行售票的代码。

对Java程序来说，只要还有一个前台线程在运行，这个进程就不会结束；如果一个进程中只有后台线程运行，这个进程就会结束。

🎐注意：这里提到的前台线程和后台线程是一种相对的概念

新创建的线程默认是前台线程
如果某个线程对象在启动之前执行了 setDaemon(true)语句，这个线程就变成了后台线程。

class DemoThread implements Runnable{
    public void run() {
        while(true){
            System.out.println(Thread.currentThread().getName() + "---在运行");
        }
    }
}

public class thread_back {
    public static void main(String[] args) {
        // 判断是否为后台线程
        System.out.println("main 线程是后台线程嘛？ --> " + Thread.currentThread().isDaemon());

        DemoThread dt = new DemoThread();
        Thread thread = new Thread(dt, "后台线程");
        System.out.println("thread 线程默认是后台线程嘛？ --> " + thread.isDaemon());

        // 将线程 thread 对象设置为 后台线程
        thread.setDaemon(true);
        thread.start();
        for(int i = 1;i <= 3; i++) {
            System.out.println(i);
        }
    }
}

上面演示了一个后台线程结束的过程，运行如下

此时结果竟然没有出现死循环的情况，分析如下：

如果将线程thread设置为后台线程，当前台主线程循环输出任务执行完毕后，整个进程就会结束，此时Java虚拟机也会通知后台线程结束
由于后台线程从接收指令到作出响应需要一定的时间，因此，输出了几次 “后台线程---在运行” 语句后，后台线程也结束了
由此说明：在进程中不存在前台线程时，整个进程就会结束

注意：要使某个线程设置为后台线程，必须在该线程启动之前进行设置，也就是说 setDaemon() 方法必须在 start() 方法之前进行调用，否则后台进程设置无效

四、线程创建变形（了解）📚

💫 1. 匿名内部类创建 Thread 子类对象

public static void main(String[] args) {
    // 匿名内部类 继承 Thread，重写run
    Thread t =new Thread() {
        @Override
        public void run() {
            System.out.println("使用匿名类创建 Thread 子类对象");
        }
    };

    t.start();
    System.out.println("main （） 主方法");
}

💫 2. 匿名内部类创建 Runnable 子类对象

public static void main(String[] args) {
    // 匿名内部类 实现 Runnable，重写run
    Thread t = new Thread(new Runnable(){
        @Override
        public void run() {
            System.out.println("使用匿名类创建 Runnable 子类对象");
        }
    });

    t.start();
    System.out.println("main （） 主方法");
}

💫 3. lambda 表达式

lambda 表达式可以简化多线程的创建和调用过程，在创建线程时候可以指定线程调用的方法，格式如下：

Thread t = new Thread(()->{
    }
});

使用如下：

public static void main(String[] args) {
    Thread t = new Thread(() ->{
        System.out.println("lambda 表达式创建 Runnable 子类对象");
    });

    t.start();
    System.out.println("main （） 主方法");
}

5. 多线程的优势 -- 增加运行速度💦

可以观察多线程在一些场合下是可以提高程序的整体运行效率的。

使用 System.nanoTime() 可以记录当前系统的纳秒级时间戳.
serial 串行的完成一系列运算
concurrency 使两个线程并行的完成同样的运算.

public class thread_advantage {
    private static void concurrency() throws InterruptedException {
        long begin = System.nanoTime();

        // 利用一个线程计算 a 的值
        Thread thread = new Thread(new Runnable(){
            @Override
            public void run() {
                int a = 0;
                for (long i = 0; i < count; i++) {
                    a--;
                }
            }
        });
        thread.start();
        // 主线程内计算 b 的值
        int b = 0;
        for (long i = 0; i < count; i++) {
            b--;
        }
        // 等待 thread 线程运行结束
        thread.join();

        // 统计耗时
        long end = System.nanoTime();
        double ms = (end - begin) * 1.0 / 1000 / 1000;
        System.out.printf("并发: %f 毫秒%n", ms);
    }

    private static void serial() {
        // 全部在主线程内计算 a、b 的值
        long begin = System.nanoTime();
        int a = 0;
        for (long i = 0; i < count; i++) {
            a--;
        }
        int b = 0;
        for (long i = 0; i < count; i++) {
            b--;
        }
        long end = System.nanoTime();
        double ms = (end - begin) * 1.0 / 1000 / 1000;
        System.out.printf("串行: %f 毫秒%n", ms);
    }
    
    // 多线程并不一定就能提高速度，可以观察，count 不同，实际的运行效果也是不同的
    private static final long count = 10_0000_0000;
    public static void main(String[] args) throws InterruptedException {
        // 使用并发方式
        concurrency();
        // 使用串行方式
        serial();
    }
}

// 运行结果如下：
并发: 381.155400 毫秒
串行: 674.797500 毫秒