JUC学习笔记-线程

Hi~HO~

已于 2024-09-25 18:00:10 修改

阅读量716

点赞数 15

文章标签：学习笔记 java

于 2024-09-25 16:56:40 首次发布

本文链接：https://blog.csdn.net/weixin_45941004/article/details/142528005

版权

1. 线程

1.1 线程的创建和运行

方法一：直接使用Thread

我们创建main的函数是一个主线程，main里创建的new Thread()算是另一个线程

public static void main(String[] args) {
    Thread thread = new Thread() {
        @Override
        public void run() {
            log.debug("running");
        }
    };
    thread.setName("t1");
    thread.start();
    log.debug("running");
}

11:12:20 [main] c.Test1 - running
11:12:20 [t1] c.Test1 - running

运行结果可以看到，这俩线程是同时启动的，main主线程首先启动并输出，t1线程随后

方法二：Runnable配合Thread（推荐）

把线程和任务分开，线程是线程，任务是任务

public static void main(String[] args) {
    Runnable r = new Runnable() {
        @Override
        public void run() {
            log.debug("running");
        }
    };
    //Runnable r = () -> {log.debug("running");};lambda简化
    Thread t = new Thread(r, "t2");
    t.start();
    log.debug("running");
}

比较方法一和方法二

方法 1 是把线程和任务合并在了一起（直接操作线程对象），方法 2 是把线程和任务分开了（让我们操作任务对象）
用 Runnable 更容易与线程池等高级 API 配合
用 Runnable 让任务类脱离了 Thread 继承体系，更灵活。

在源码中Runnable 作为target，如果不为空其实还是执行了run方法，两方法底层还是同源的

@Override
public void run() {
    if(target!=null){
        target.run();
    }
}

题外话：在源码中看到@FunctionaIinterface，说明该接口只有一个方法，可以用lambda简化

方法三：FutureTask配合 Thread

FutureTask是Runnable的拓展,其间接实现了Runnable的接口，此外多了Future接口（含get方法）；可返回任务的执行结果，可以方便的在两个线程间传递结果

public static void main(String[] args) throws ExecutionException, InterruptedException {
    FutureTask<Integer> task = new FutureTask<Integer>(() -> {
        log.debug("running...");
        Thread.sleep(2000); // 休眠
        return 100;
    });
    //把任务传给线程, FutureTask实现RunnableFuture接口，RunnableFuture继承自Runnable
    Thread t1 = new Thread(task, "t1");
    t1.start();
    // main主线程需要阻塞2秒以获取t1线程的返回值
    log.debug("{}",  task.get());
}

FutureTask 类是 Future 接口和 Runable 接口的实现。弥补了 runnable 创建线程没有返回值的缺陷

linux系统查看线程命令：ps -fe
java查看线程：jps

1.2 线程运行原理

栈与栈帧

jvm由包含栈、堆、方法区组成，其中栈内存是给线程使用的，每个线程启动后jvm就会为其分配一块栈内存。多个线程间的栈内存相互独立，互不干扰

每个栈由多个栈帧组成（Frame），对应每次调用方法都会占用的内存
每个线程只能有一个活动栈帧，对应着当前正在执行的那个方法

在一个栈内，方法调用遵循着后进先出（栈）的规则，每调用一个方法可观察到栈帧内多出一个方法以及方法内的参数

在这里插入图片描述
jvm实例图

1.3 Thread中的常见方法

1.3.1 start()和run()

方法名	static	功能说明	注意
start()		启动一个新线程，在新线程中运行 run 方法中的代码	start 方法只是让线程进入就绪状态，里面代码不一定立刻运行，只有当 CPU 将时间片分给线程时，才能进入运行状态，执行代码。每个线程的 start 方法只能调用一次，调用多次会出现 `IllegalThreadStateException`
run()		新线程启动会调用的方法	如果在构造 Thread 对象时传递了 Runnable 参数，则线程启动后会调用 Runnable 中的 run 方法，否则默认不执行任何操作。但可以创建 Thread 的子类对象，来覆盖默认行为

public static void main(String[] args) {
    Thread t1 = new Thread(new Runnable() {
        @Override
        public void run() {
            log.info(Thread.currentThread().getName() + " running....");
        }
    }, "t1");
    // 直接调用 run 方法
    t1.run();
    //调用start方法
//  t1.start();
    log.info(Thread.currentThread().getName() + " running...");
}

调用run

14:56:56 [main] c.Code_05_Test - main running....
14:56:56 [main] c.Code_05_Test - main running...

调用start

14:59:35 [main] c.Code_05_Test - main running...
14:59:35 [t1] c.Code_05_Test - t1 running....

由运行结果可以看出，直接调用run不会新建一个线程，仍然由main主线程执行方法，并没有起到异步加速的作用，而start方法时则是创建了新的线程，实现了异步

start()方法：

调用线程的start()方法实际上启动了一个新的执行线程。这意味着Java虚拟机会为该线程分配必要的系统资源，如独立的栈空间、程序计数器等。
当start()被调用后，JVM会安排新线程在某个时间点上执行该线程的run()方法。这意味着调用start()后，当前线程（调用者线程）不会等待新线程中的run()方法执行完毕，而是会立即继续执行下一条语句，实现了并发执行。
start()方法只能被调用一次，多次调用会抛出IllegalThreadStateException异常。

run()方法：

run()方法包含了线程执行的具体任务代码。它是线程执行时需要完成的工作内容。
如果直接在主线程中调用某个线程对象的run()方法，那么run()方法中的代码将像普通方法一样在当前线程中顺序执行，而不会创建新的线程。这意味着直到run()方法中的所有代码执行完毕，当前线程才会继续执行后续代码，没有实现多线程的并行或并发执行效果。
run()方法可以被多次调用，每次调用都会执行其包含的代码逻辑，但始终是在调用它的线程上下文中执行。

1.3.2 sleep()与yield()

sleep(使线程阻塞)

调用 sleep 会让当前线程从 Running 进入 Timed Waiting 状态（阻塞），可通过state()方法查看
其它线程可以用 interrupt 方法打断正在睡眠的线程，这时 sleep 方法会抛出InterruptedException
睡眠结束后的线程未必会立刻得到执行
建议用 TimeUnit 的 sleep 代替 Thread 的 sleep 来获得更好的可读性

yield(让出当前线程)

调用 yield 会让当前线程从 Running 进入 Runnable 就绪状态（仍然有可能被执行），然后调度执行其它线程
具体的实现依赖于操作系统的任务调度器

1.3.3 join方法详解

场景：主线程需要根据线程T1的结果进行输出，为了保证T1线程率先执行完得到正确结果；需要让主线程等待，seelp可以，但是seelp必须填时间，实际上我们不知道填多长合适。因此这种情况需要使用join方法。

join()方法用于等待某个线程结束。哪个线程内调用join()方法，就等待哪个线程结束，然后再去执行其他线程。
如在主线程中调用T1.join()，则是主线程等待T1线程结束，join 采用同步。

int r = 0;
public static void main(String[] args) {
    Thread t1 = new Thread(new Runnable() {
        @Override
        public void run() {
          for (int i = 0; i <20 ; i++) r++;
        }
    }, "t1");
    t1.start();
    t1.join();   //join(1000),方法内可填等待时间，表示最多等待1000ms，防止无限等待下去
    log.debug("r = {}", r);
}

1.3.4 interrupt()方法

interrupt 打断线程有两种情况：

如果一个线程在运行中被打断，打断标记会被置为 true 。
如果是打断因sleep wait join 方法而被阻塞的线程，会将打断标记置为 false 。

*Thread.currentThread().isInterrupted()*获得打断标记，注意interrupt()方法并只能改变打断标记，当打断标记为ture时线程就可以知道外部有别的线程希望终止自己，但是否停止可以交给线程自己决定，换句话说线程可以不理会打断继续执行，也可以选择终止。

isInterrupted()获得打断标记，除了该方法外还有interrupted()方法也可获得打断标记

isInterrupted() 与 interrupted() 比较：

在Java中，isInterrupted() 和 interrupted() 都与线程中断有关，但它们在使用场景和行为上有所区别：

isInterrupted()：
- 这是 Thread 类的一个方法，它用于查询某个线程是否被中断，而不会改变中断状态。也就是说，如果线程之前被中断过，调用 isInterrupted() 返回 true，但调用之后中断标志依旧保持为 true。
- 使用格式：thread.isInterrupted()
- 由于这个方法不会清除中断状态，它常用于需要检查中断状态但不立即处理中断的场景，比如在循环中检查是否应该提前退出。
interrupted()：
- 这是一个静态方法，同样属于 Thread 类。它也用于检查当前线程（即调用该方法的线程）是否被中断，并且会清除中断状态。这意味着，如果线程之前被中断，调用 interrupted() 会返回 true，并且之后再调用会返回 false，直到线程再次被中断。
- 使用格式：Thread.interrupted()
- 由于该方法会清除中断状态，它通常用于响应中断的场景，即检查到中断后立即进行相应的清理或退出操作，并且期望在此之后的中断检查能反映出新的中断状态。

总结来说，选择使用 isInterrupted() 还是 interrupted() 主要取决于你是否希望在检查中断状态后清除这个状态。如果需要保留中断状态供后续检查，则使用 isInterrupted()；如果需要在检查后重置中断状态，以便可以响应新的中断请求，则应使用 interrupted()。

1.4 线程的状态

1）线程的5种状态

从操作系统的层面上进行划分可分为5种状态
在这里插入图片描述

初始状态：创建了线程对象，即Thead thread = new Thead();还未调用start())方法。
可运行状态(就绪态)：指该线程已经被创建，与操作系统相关联，等待cpu给它分配时间片就可运行。
运行状态：指线程获取了CPU时间片，正在运行当CPU时间片用完，线程会转换至【可运行状态】，等待 CPU再次分配时间片，会导致我们前面讲到的上下文切换。
阻塞状态：

如果调用了阻塞API，如BIO读写文件，那么线程实际上不会用到CPU，不会分配CPU时间片，会导致上下文切换，进入【阻塞状态】
等待BIO操作完毕，会由操作系统唤醒阻塞的线程，转换至【可运行状态】
与【可运行状态】的区别是，只要操作系统一直不唤醒线程，调度器就一直不会考虑调度它们，CPU就一直不会分配时间片

终止状态：表示线程已经执行完毕，生命周期已经结束，不会再转换为其它状态

2）线程的6种状态

在Java种，线程被分为了6种状态

初始：线程已创建，未运行
运行：在java中，运行(Runnable)态涵盖了运行中(Running)和就绪（ready），在调用start()方法后线程等待cpu时间片的到来这时称为就绪态，当线程获得cpu时间片开始运转时称之为运行态。
阻塞：线程在执行时进入synchronized关键字修饰的方法或代码块(获取锁)时的状态。
等待：处于这种状态的线程不会被分配CPU执行时间，它们要等待被显式地唤醒，否则会处于无限期等待的状态。下图，常见的wait，join方法没有定时参数时可使线程进入等待状态。它们需要用notify进行显示唤醒。
超时等待：处于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒。下图，常见的sleep，wait，join方法加入定时参数后可使线程进入超时等待
终止

就绪(ready)：

在Java中，以下操作可以导致线程进入就绪（Ready）状态：

调用线程的 start() 方法：当一个新的线程被创建后，它的初始状态是新建（New）。调用该线程的 start() 方法会将线程状态从新建变为就绪。此时，线程进入线程调度器的可执行队列，等待CPU分配时间片。
线程从阻塞状态恢复：
- 当一个正在运行的线程因为调用了 sleep() 方法而睡眠，一旦睡眠时间结束，线程会从阻塞状态转为就绪状态。
- 当线程因为等待 join() 方法结束而阻塞，一旦被加入的线程执行完毕，该线程也会变为就绪状态。
- 如果线程因等待输入输出（I/O）操作而被阻塞，一旦这些操作完成，线程变为就绪状态。
- 获得对象监视器锁，如果线程之前因为试图获取对象的监视器锁（即进入同步块）而被阻塞，一旦获得锁，它将进入就绪状态。
- 总结：当前线程sleep()方法结束、其他线程join()结束、等待用户输入完毕、线程拿到对象锁
线程被中断（虽然直接中断不会使线程进入就绪状态，但可以通过中断来唤醒某些等待条件的线程，如使用 wait() 方法等待的线程，这间接使其能进入就绪状态）。
时间片用尽：如果一个正在运行的线程用完了它的时间片，它会被重新安排到就绪状态，而不是直接回到运行状态，等待下一次CPU调度。