多线程基础

咸鱼没有不粘锅

已于 2023-03-01 17:30:26 修改

阅读量60

点赞数

文章标签： java intellij-idea Powered by 金山文档

于 2023-02-22 14:57:16 首次发布

本文链接：https://blog.csdn.net/weixin_60007218/article/details/129102325

版权

JavaEE基础专栏收录该内容

24 篇文章 0 订阅

订阅专栏

线程

一个线程就是一个“执行流”，每个线程之间都可以按照顺序执行自己的代码，多个线程之间同时执行多份代码。

进程和线程的区别

2.1 进程

我们了解过进程就是任务，是运行起来的程序，进程是为了能让操作系统可以同时执行多个任务，实现“并发编程（并发加并行）”的效果，可以充分利用多核CPU资源。

2.2 线程

虽然多进程已经实现了并发编程，但是仍存在问题：如果频繁创建或销毁进程，这个操作会比较低效，分配及释放资源对操作系统来说需要消耗很多资源，线程的出现解决了以上问题，进程包含一个或多个线程，每个线程都是一个“执行流”，可以单独在CPU上进行调度，同一个进程中的线程共用同一份系统资源（内存＋文件）。

2.3 区别

进程包含线程，每个进程至少有一个线程存在，称为主线程；

线程比进程更轻量，创建更快，销毁也更快；

同一个进程的多个线程之间共用一份内存/文件资源，进程和进程之间是独立的内存/文件资源；

进程是系统分配资源的最小单位，线程是系统调度的最小单位

Thread

线程的相关操作在操作系统中提供了一系列API，Java将这些C语言的API封装成Java风格。

3.1 线程创建

3.1.1 继承Thread创建线程类

继承Thread创建一个线程类；

创建MyThread 类实例；

调用start 方法启动线程。

标准库中提供了Thread类，使用的时候可以直接继承这个类，run 是 Thread父类里已经有的方法，重写run方法，run 就是这个线程要执行的工作，调用 start 方法的时候才是真正创建出一个新线程。默认的线程就是 main 方法所在的线程，也叫主线程。main 所在的线程和 MyThread 创建的新线程是“并发执行”的关系。（run 和 start 的区别）

3.1.2 实现Runnable接口

实现 Runnable 接口；

创建 Thread 类实例, 调用 Thread 的构造方法时将 Runnable 对象作为 target 参数；

调用 start 方法。

3.1.3 使用匿名内部类创建 Thread 子类对象

3.1.4 使用匿名内部类创建 Runnable 子类对象

3.1.5 lambda 表达式创建 Runnable 子类对象

这是最简单的一种写法，推荐使用这种写法。

线程创建不止这五种方法，还有另外两种方法。

3.1.6 串行 VS 并行

使用 System.nanoTime() 可以记录当前系统的纳秒级时间戳；

serial 串行的完成一系列运算. concurrency 使用两个线程并行的完成同样的运算。

如果计算量大、计算的久，创建线程的开销可以忽略不计；如果计算量小、计算的快，创建线程的开销影响较大，多线程无法明显起到加快速的的作用。

3.2 线程等待

控制线程之间的结束顺序

package threading;

// 线程等待
public class Demo12 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            for (int i = 0; i < 5; i++) {
                System.out.println("hello thread!");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        });
        t.start();

        System.out.println("main 线程 join 之前");
        try {
            t.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("main 线程 join 之后");
    }
}

hello thread 不是百分百在main 线程 join 之前之后执行的，这个需要根据操作系统的调度，但是由于调用start 执行新线程需要做准备工作，因此可能大概率在main之后执行。

3.3 线程中断

3.3.1 定义标志位作为线程是否结束的标记

package threading;

// 线程中断
public class Demo10 {
    private static boolean isQuit = false;

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

        t.start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        isQuit = true;
        System.out.println("设置让 t 线程结束!");
    }
}

3.3.2 标准库自带的标志位

package threading;

// 线程中断
public class Demo11 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> {
            //currentThread()是Thread类的静态方法，通过这个方法就能拿到当前线程的实例
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("hello thread");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // e.printStackTrace();

                    // 线程自身处理方式一：立即结束线程
                    break;
                    // 方式二：不做理会，线程继续执行

                    // 方式三：稍后处理
                    // Thread.sleep(1000);
                    // break;
                }
            }
            System.out.println("t 线程执行结束");
        });

        t.start();

        try {
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 在中线程中以次中断此线程，设置标志位为true
        t.interrupt();
        System.out.println("设置让 t 线程结束!");
    }
}

执行结果同上。