【多线程】概述

王彬泽

已于 2024-09-06 09:21:16 修改

阅读量1.1k

点赞数 18

分类专栏：多线程文章标签：多线程 Thread Java

于 2024-09-04 22:02:15 首次发布

本文链接：https://blog.csdn.net/weixin_73060900/article/details/141873016

版权

多线程专栏收录该内容

2 篇文章 0 订阅

订阅专栏

进程与线程

概述

一个正在运行过程中的程序，就是一个进程，也称一个任务。进程是一个重要的软件资源，是由操作系统内核管理和组织的。

并行：微观上同一个时刻，两个核心上的进程，就是同时进行的。

并发：微观上同一个时刻，一个核心只能运行一个进程，但是它能够对进程进行快速的切换。

在计算机领域，引入进程这个概念，最主要就是为了解决并发编程。对于并发编程，则是因为CPU进入了多核心时代，要想进一步提高程序的执行速度，就要充分利用CPU的核心资源。虽然多进程编程能够解决并发编程的问题，但是进程在创建、销毁以及调度时消耗的资源是比较多的（尤其体现于资源的分配和回收上），因此为了解决该问题，线程这个概念就被提及，线程其实也称为轻量级进程。线程在能解决并发编程问题的前提下，让创建、销毁和调度的速度都提高了不少。对于提高其速度的原因，主要就是因为线程把申请资源和释放资源的操作给省略了。

关系

一个进程可以包含一个线程，也可以包含多个线程，但是不能没有。对于一个进程而言，只有开启第一个线程时消耗的资源较大，后续开启其他线程时消耗的资源都相对较少。主要原因就是后续线程开启时的某些资源都可以复用。

操作系统在实际调度时，是以线程为调度的基本单位。操作系统在资源分配时，则是以进程为资源分配的基本单位。

所以说，对于线程模型来说，天然就是资源共享的，会导致多个线程争抢同一个资源，从而引发一定的安全问题。对于进程模型来说，天然就是资源隔离的，不容易触发问题，只有当进程间进行通信的时候，才会出现多个进程访问同一个资源，从而导致一定的安全问题。

综上所述，对于线程来说，最大的特定就是抢占式执行，随即调度。

在Java中如何进行多线程编程

Java操作多线程，最核心的类是：Thread

简单案例

在使用Thread之前，要明白在Java中，执行main函数时就相当于开启了一个进程，并且main线程属于是主线程。并且，创建线程，是希望线程成为一个独立的执行流去执行一块代码。简单来说，就是创建线程之后，新的线程和main线程是可以并行执行的。

需求：使用非main线程的线程输出一个“shello World！”

class MyThread extends Thread {
    
    @Override
    public void run() {
        System.out.println("hello world！");
    }
    
}

public class SimpleThreadTest {

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

}

方法介绍

start方法的工作是创建一个新的线程，新的线程负责执行run方法。本质来说，start方法是调用了操作系统的API，通过操作系统内核去创建新线程的PCB，并且把要执行的指令交给PCB。当PCB调度到CPU上执行的时候，也就执行到了run方法中的代码了。

run方法就是描述了线程要干的活是啥，如果直接在main线程中执行run方法，那么此时并不会创建新线程，而是main线程在干活。

start和run方法的区别是前者是开启线程，后者是描述线程要干的活。

对于一个线程来说，start方法只能执行一次，而且在run方法执行完毕之后，新的线程自然销毁。

创建多线程的方法

继承Thread类，并重写run方法

class MyThread extends Thread {

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

}

public class SimpleThreadTest {

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

}

实现Runnable接口，并重写run方法

继承Runnable接口就能创建多线程的原因是因为：底层源码中，Thread实现了Runnable接口。

class MyRunnable implements Runnable{

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

}

public class Demo2 {

    public static void main(String[] args) {
        Runnable runnable = new MyRunnable();
        Thread thread = new Thread(runnable);
        thread.start();
    }

}

使用匿名内部类，继承Thread

    public static void main(String[] args) {
        Thread thread = new Thread() {
            @Override
            public void run() {
                System.out.println("hello world");
            }
        };
        thread.start();
    }

使用匿名内部类，实现Runnable

    public static void main(String[] args) {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("hello world");
            }
        });
        thread.start();
    }

使用Lambda表达式

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

构造方法和常见属性

构造方法

常见属性

tid（getId）：线程唯一标识。
名称（getName）：线程的名称，开发者可以在构造方法或使用set方法设置，如果没有设置，也会默认生成一个名称。
状态（getState）：线程的状态（后续会进行详细介绍）。
优先级（getPriority）：虽然线程中有优先级这一概念，并且也可以进行设置和获取，但其实设置了也没啥大用，很鸡肋的一个属性。
前后台线程（isDaemon）：前台线程会阻止进程结束，假设前台线程任务没有结束，那么进程是结束不了的；在代码中手动创建的线程，默认都是前台线程。后台线程不会阻止进程的结束，即使后台线程任务没有结束，进程也是可以结束的；像其他的JVM自带的线程都是后台的。在Thread的操作中，也可以将线程设置成后台线程，而所谓的后台线程也是守护线程。
存活（isAlive）：线程在调用start之前，就处于存活状态；在调用start之后，就处于死亡状态太。

常见方法

获取当前线程的引用：在哪个方法中进行调用，就能获取到哪个线程的实例。

等待一个线程：由于线程是一个随机调度的过程，无法判断哪个线程先调度，哪个线程后调度。等待一个线程的意思就是控制两个线程的顺序。

public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
           for (int i = 0; i < 3; i++) {
               System.out.println("hello thread");
           }
        });
        thread.start();
        System.out.println("join之前");
        thread.join();
        System.out.println("join之后");
        // 本来main线程执行完start之后，main线程和start线程就会分头行动
        // main线程继续向下执行，start线程也继续向下
        // 但是加入join之后，main线程就会发送阻塞
        // 一直阻塞带thread线程结束之后，main线程才会继续向下执行
    }

    /**
     * 简单案例
     * a、b、main线程三个线程
     * 阻塞b线程直到a线程结束之后
     */
    public static void main(String[] args) throws InterruptedException {
        Thread a = new Thread(() -> {
            for(int i = 0; i < 3; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("aaa");
            }
        });
        a.start();

        Thread b = new Thread(() -> {
            try {
                a.join();
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("bbb");
        });
        b.start();
    }

休眠当前线程：让线程休眠，也就是让线程不参与调度了（或者说也就是不去CPU上执行了）。

对于操作系统内核来说，当线程A调用sleep时，线程A就会进入休眠状态。此时就会把A放入一个链表中，这个链表当中的PCB，都是处于阻塞状态，暂时都不会去参加CPU的调度。此时，其他可以运行的PCB则处于另一个链表上，处于一种随叫随到的状态，也就是就绪状态。

第一类链表称作阻塞队列，第二类链表则称作就绪队列。在计算机运行过程中，操作系统每次需要调度一个线程去执行，那么就直接从就绪队列中选取一个即可。

多线程的意义是啥

多线程的主要作用就是提高程序的执行速率。

程序一般分为CPU密集型，包含大量的加减乘除等算术运算；IO密集型，包含到读写文件、读写控制台和读写网络等。

多线程在这种CPU密集型的任务中有非常大的作用，可以充分利用CPU的多核资源，从而加快程序的运行的效率。并不是说所有的程序都可以使用多线程来提高效率，首先考虑CPU是否多核，然后就是考虑当前核心是否空闲。如果计算机是单核或者核心都已经满载了，那么启动再多的线程也没啥用。

多线程在这种IO密集型的任务中也有非常大的作用，例如在日常使用的一些程序，经常看到程序未响应，这表示程序进行了一些耗时的IO操作，阻塞了界面的响应。这种情况下就可以使用一个线程来负责响应IO，一个线程来负责响应用户的操作（该情况主要针对客户端开发）。

    public static void main(String[] args) throws InterruptedException {

        long noUsedThread = noUsedThread();
        
        long usedThread = usedThread();

        System.out.println("未使用多线程：" + noUsedThread);
        System.out.println("使用多线程：" + usedThread);
        
    }

    private static long usedThread() throws InterruptedException {

        long begin = System.currentTimeMillis();
        Thread t1 = new Thread(() -> {
            long a = 0;
            for(long i = 0; i < 10000000000L; i++) {
                a++;
            }
            System.out.println(a);
        });
        Thread t2 = new Thread(() -> {
            long b = 0;
            for(long i = 0; i < 10000000000L; i++) {
                b++;
            }
            System.out.println(b);
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        long end = System.currentTimeMillis();
        return end - begin;
    }

    private static long noUsedThread() {

        long begin = System.currentTimeMillis();
        long a = 0, b = 0;
        for(long i = 0; i < 10000000000L; i++) {
            a++;
        }
        for(long i = 0; i < 10000000000L; i++) {
            b++;
        }
        long end = System.currentTimeMillis();
        System.out.println(a);
        System.out.println(b);
        return end - begin;

    }