JUC知识点三

最新推荐文章于 2024-08-23 15:54:50 发布

明日春风

最新推荐文章于 2024-08-23 15:54:50 发布

阅读量1.3k

点赞数 50

文章标签： java 开发语言

本文链接：https://blog.csdn.net/weixin_53676834/article/details/137880131

版权

执行TestFrames这个类的时候发生了什么呢？

1、首先执行一个类加载，把TestFrames这个类的二进制字节码加载到java虚拟机中的方法区内存中（其实是二进制的字节码，只是为了好理解才写的源代码）；

2、类加载完成了之后，java虚拟机就会启动一个名称叫做main的主线程，并且给这个主线程分配一块栈内存空间，，然后线程就交给任务调度器去调度执行。

3、比如CPU时间片分给了我们的主线程了，那CPU 就会运行主线程内的代码。主线程的代码入口都是main方法，所以会由虚拟机再去给线程分配一块栈帧内存，调用栈帧内存之前，我们栈中有一个程序计数器，是线程私有的，他记录了我当前线程应该执行哪一行代码，将来CPU 就会找程序计数器要你下一行代码

Java中线程状态：

Java中线程状态是用6个enum表示，分别为:

①、NEW, ②、RUNNABLE, ③、BLOCKED,

④、WAITING, ⑤、TIMED_WAITING, ⑥、TERMINATED

线程的生命周期：

如何创建线程：

通常来说，可以认为有三种方式：
        1）继承 Thread 类；
        2）实现 Runnable 接口；
        3）实现 Callable 接口。

其中，Thread 其实也是实现了 Runable 接口。Runnable 和 Callable 的主要区别在于是否有返回值。

当线程创建成功时，线程处于NEW（新建）状态，如果你不调用start( )方法，那么线程永远处于NEW状态。调用start( )后，会启动线程，让线程从NEW（新建）状态变为RUNABLE状态，可运行状态/就绪状态

一、start方法：

为什么需要start方法；它的作用是什么?

1、start（）方法是用来启动一个新线程，真正实现多线程运行，调用start( )后，会让线程从NEW（新建）状态变为RUNABLE状态，可运行状态/就绪状态；

2、调用start（）方法后，线程不一定马上执行，线程要等待CPU调度，由操作系统的任务调度器去决定 CPU的时间片分给哪个线程去使用，不同的JVM有不同的调度算法。

3、一旦得到cpu时间片，线程就开始执行run()方法，这里方法 run()称为线程体，它包含了要执行的这个线程的内容，run()方法运行结束，此线程随即终止。

3、Thread 类中的 start() 方法调用了本地方法（native method）。本地方法是用C或C++等语言编写的方法，它们通过Java Native Interface（JNI）与Java虚拟机进行通信，start() 方法的本地实现主要负责与操作系统交互，创建并启动新的操作系统线程。

4、注意：

线程只能调用一次start()方法，只能启动一次，不能多次调用start()方法，多次启动一个线程会抛出异常，因为在线程的生命周期中，线程的状态由NEW ----> RUNABLE只会发生一次。特别是当线程已经结束执行后，不能再重新启动，因为死亡的线程不能再次启动： IllegalThreadStateException：非法的线程状态异常

二、run()方法：

当调用了线程对象的start()方法，并且获得了CPU分配的时间片后，线程就会开始运行，自动调用线程的run方法，run()方法中包含了这个线程启动后要执行的内容: 如果是在构造Thread对象时传递了Runnable参数，则线程启动后会调用Runnable中的run方法，如果这个run()方法被子类重写了，那就运行子类中run()的方法;

如果在构造Thread对象时传递了Runnable参数，则线程启动后会调用Runnable中的run方法，否则默认不执行任何操作。但可以创建Thread 的子类对象，来覆盖默认行为

三、直接调用run()方法会怎么样：

直接执行run()方法，并不会去开辟一个新的线程，直接执行run()方法，会把run方法当成一个主线程下的普通方法去执行，并不会在某个线程中执行它，并没有起到多线程的效果：

Thread 调用 start() 方法和调用 run() 方法的区别

run()：直接执行run()方法，并不会去开辟一个新的线程，直接执行run()方法，会把run方法当成主线程下的一个普通方法去执行，并不会在某个线程中执行它，并没有起到多线程的效果
start()：启动一个新线程，真正实现多线程运行，调用start( )后，会让线程从NEW（新建）状态变为RUNABLE状态，可运行状态/就绪状态；并没有运行，一旦得到 CPU 时间片，就开始执行 run() 方法。

真正理解Thread类：

Thread类的对象其实也是一个java对象，只不过每一个Thread类的对象对应着一个线程。Thread类的对象就是提供给用户用于操作线程、获取线程的信息。真正的底层线程用户是看不到的了。
因此，当一个线程结束了，死掉了，对应的Thread的对象仍能调用，除了start( )方法外的所有方法（死亡的线程不能再次启动），如run( )、getName( )、getPriority（）等等

Thread.sleep(long millis)方法：

1、调用sleep会让当前线程从Running(Runnable)进入Timed_Waiting，阻塞状态，让这个线程去睡眠，处于睡眠状态的线程会自动放弃cpu时间片的使用权，让其他线程去运行、使用cpu，但不释放锁资源，millis后线程自动苏醒进入就绪状态。
2、其它线程可以使用interrupt()方法打断正在睡眠的线程，这时sleep方法会抛出InterruptedException

3、睡眠结束后的线程处于就绪状态，未必会立刻得到执行，需要等到操作系统的任务调度器把新的CPU时间片分给这个线程以后，它才能继续运行

4、Thread.sleep()写在哪个线程中就让哪个线程睡眠，是让当前线程睡眠
5、建议用TimeUnit的sleep代替Thread 的sleep来获得更好的可读性

举例一：

举例二：

如果没有这个唤醒啊，它就等睡足两秒，但是中途啊可以用这个interrupt方法给它打断:

处于阻塞状态的线程一定会放弃cpu时间片吗

Thread.yield()让出、谦让

调用Thread.yield()表示当前线程愿意放弃当前CPU时间片的使用权，但不释放锁资源，会让当前线程从运行状态Running变为绪状态Runnable，作用是有可能给相同优先级或更高优先级的线程执行的机会，但是调用Thread.yield()的线程有可能再次被操作系统的任务调度器分配到CPU时间片

Thread.sleep()方法和Thread.yield()方法二者区别：

1、调用Thread.sleep(millis)方法会让当前线程从Running(Runnable)运行状态进入超时等待Timed_Waiting，阻塞状态，操作系统的任务调度器不会把CPU时间片分配给阻塞状态的线程，让这个线程去睡眠，处于睡眠状态的线程会自动放弃cpu时间片的使用权，让其他线程去运行、使用cpu，但不释放锁资源，millis后线程自动苏醒进入就绪状态。
2、调用Thread.yield()表示当前线程愿意放弃CPU时间片的使用权，但不释放锁资源，会让当前线程从运行状态Running变为就绪状态（READY） Runnable，还是有机会被分配到CPU时间片。
3、调用Thread.sleep()方法的线程会释放CPU的时间片以便让其他线程获得执行机会，而调用Thread.yield()方法的线程有可能会再次被操作系统的任务调度器分配到CPU时间片，不保证其它线程一定能获取执行机会。
3、 sleep()方法声明需要抛出 InterruptedException，其它线程可以使用interrupt()方法打断正在睡眠的线程，而 yield()方法不需要声明任何异常；
4、调用Thread.sleep()方法给其他线程运行机会时不需要考虑线程的优先级，因此会给低优先级的线程运行的机会；yield() 方法只会给相同优先级或更高优先级的线程运行的机会。
5、sleep()方法比yield()方法具有更好的移植性。

精准的时间控制：sleep 方法能够精确地指定线程休眠的时间，而 yield 方法只是一种提示，调度器可以忽略它。这使得 sleep 在需要精确时间控制的场景中更为可靠
6、yield /sleep不会释放对象锁，别的线程进入不了。

sleep() 方法的应用场景

定时任务。通过 Thread.sleep() 方法可以让线程暂停指定时间（例如1000毫秒），然后再执行后续任务。
控制循环速度。有时候需要让循环的执行速度变慢或更快，此时可以使用 Thread.sleep() 来控制每次循环的暂停时间。
模拟网络延迟。在开发网络应用程序的过程中，我们常常需要模拟网络传输时的延迟情况，通过调用 Thread.sleep() 方法来模拟数据包在网络传输中的延迟。

yield() 方法的应用场景

提高线程的并发度。当某个线程占用 CPU 时间过长时（例如在计算复杂的任务时），就会降低系统的并发度。通过在适当的时间点上调用 Thread.yield() 方法，能够使该线程让出 CPU 时间片，从而提高系统的并发度。
改善线程间的相对优先级。例如有两个线程的优先级相同，但一个线程必须完成某些重要的初始化工作，这时就可以在其它线程上调用 Thread.yield() 方法，使其它线程的代码早些运行，从而把执行控制让给初始化工作可能更为关键的线程。

线程对象.join()/join(long n)

用于等待某个线程结束。调用了哪个线程对象的join方法，当前线程就等待哪个线程结束后再往下执行。

为什么需要join：

我们先来看一段代码啊，大家分析下它这个最终打印的结果R到底是什么:

打印出来结果是多少呢？并不是10,是0:

因为主线程不会等这个线程1的sleep结束，主线程会继续向下运行。它俩是并发运行的，这也是我们以前讲的那种异步机制：主线程不用去等线程1的结果，那如何在主线程里获取这个R=10这个结果呢：让主线程等待t1线程运行结束

Java中为什么不建议使用stop和suspend方法终止线程

Java中不建议使用 stop() 和 suspend() 方法来终止线程，主要是因为它们存在一些严重的问题和风险：

stop() 方法：这个方法会立即终止线程的执行，可能导致线程在执行过程中处于不一致的状态，比如可能会导致对象锁的释放问题，从而引发数据不一致或死锁等问题。
suspend() 方法：这个方法会暂停线程的执行，但不会释放它所持有的任何锁资源。如果一个线程被暂停了而不释放锁资源，其他线程可能会被永久地阻塞，从而引发死锁。

由于这些方法可能导致严重的线程安全问题和应用程序错误，因此Java官方不建议使用它们。相反，推荐使用更安全的方式来控制线程的执行，比如使用 interrupt() 方法来中断线程，并在线程中处理中断信号以安全地停止线程的执行。另外，可以使用 wait() 和 notify() 等方法来实现线程之间的协作和通信。

总之，使用 stop() 和 suspend() 方法是不安全的，容易引发线程安全和应用程序错误，因此应尽量避免使用它们，而是采用更安全的方式来管理和控制线程的执行。

阻塞状态的线程

接下来呢我们学习一个也是比较重要的方法，叫做 interrupt 它是可以用来打断啊正在睡眠的线程。当然，它除了可以打断这种睡眠线程以外啊，那其他正在运行的线程也可以用 interrupt 去打断。

分成这样两类啊，一类就是处于这种阻塞状态的线程。处于阻塞状态的线程，这个操作系统的任务调度器不会去考虑他们啊，不会主动的把时间片给他们用啊，处于阻塞状态的线程，一般呢是因为我们调用了 sleep 方法或者 wait 方法或者 join 方法啊，都会让线程进入这个阻塞状态。

wait 虽然大家还没学，但是我可以提前给大家说一下啊，join的底层原理其实就是 wait ，所以它俩其实是一回事。那这是一种情况啊：interrupt 可以用来去打断这种处于阻塞状态的线程。

它也可以用来打断那种正在运行的线程。这是两种情况

Java程序占用 CPU 过高怎么排查

我们如何快速定位并解决呢？一般会有如下三个步骤：

使用 top命令找到占用 CPU 最高的 Java 进程
找到这个进程中最耗CPU的线程
使用jdk自带工具jstack 查看堆栈信息，定位线程的什么操作消耗了大量CPU，定位对应代码

先模拟一个高 CPU 场景：

public static void main(String[] args)  {
  for (int i = 0; i < 10; i++) {
    Thread thread = new Thread(() -> {
      System.out.println(Thread.currentThread().getName());
      try {
        Thread.sleep(30 * 60 * 1000);
      }catch (Exception e){
        e.printStackTrace();
      }
    });
    thread.setName("thread-" + i);
    thread.start();
  }

  Thread highCpuThread = new Thread(() -> {
    int i = 0;
    while (true) {
      i++;
    }
  });
  highCpuThread.setName("HighCpu");
  highCpuThread.start();
}

运行这段程序后，前面 10 个线程都处于休眠状态，只有最后一个线程会持续的占用 CPU 。

排查步骤：

第一步，使用 top 找到占用 CPU 最高的 Java 进程：

在真实环境中，首先要确认是不是 Java 程序造成的，如果有系统监控工具，可能会直接在预警信息里告诉你是有哪个进程造成的，但也有可能不知道，需要我们手动排查。

如果是在面试场景中，这个问题可能不需要确认，毕竟 Java 面试，面试官可能直接就告诉你是 Java 占用的 CPU 过高。

这一步也非常简单，就是一个 top命令而已：

使用 top命令发现占用 CPU 99.7% 的线程是 Java 进程，进程 PID 为 13731。

第二步，用 top -Hp 命令查看占用 CPU 最高的线程

上一步用 top命令找到了那个 Java 进程。那一个进程中有那么多线程，不可能所有线程都一直占着 CPU 不放，这一步要做的就是揪出这个罪魁祸首，当然有可能不止一个。

执行top -Hp pid命令，pid 就是前面的 Java 进程，我这个例子中就是 13731 ，完整命令为：

top -Hp 13731，执行之后的效果如下：

可以看到占用 CPU 最高的那个线程 PID 为 13756，CPU使用率达到了99.7%

三、查看堆栈信息，定位线程的什么操作消耗了大量CPU，定位对应代码

当前 Java 程序的所有线程信息都可以通过 jstack命令查看，我们用jstack命令将第一步找到的 Java 进程的线程栈保存下来。

CPU占用率100%

导致CPU占用率如此之高的元凶就是程序中的几个while(true)死循环。

在没有利用cpu来计算时，不要让while(true)空转浪费cpu，这时可以使用yield或sleep来让出cpu的使用权给其他程序：

while(true) {
	try {
		Thread.sleep(10);
	} catch (InterruptedException e) {
		e.printStackTrace();
	}
}

可以用wait或条件变量达到类似效果
不同的是，后两种都需要加锁，并且需要相应的唤醒操作，一般适用于要进行同步的场景
sleep适用于无需锁同步的场景

明日春风

关注

50
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
JUC知识点三

run()方法的作用是启动一个新的线程，在新的线程里运行线程对象中的run方法；当你的这个新的线程启动以后，就会调用这个线程的run方法:如果有Runable对象,就运行Runable对象的run()方法，如果这个run()方法被子类重写了，那就运行子类中run()的方法;因此，当一个线程结束了，死掉了，对应的Thread的对象仍能调用，除了start( )方法外的所有方法（死亡的线程不能再次启动），如run( )、getName( )、getPriority（）等等。真正的底层线程用户是看不到的了。
复制链接

扫一扫