深入浅出讲解java线程的运行状态

最新推荐文章于 2022-10-17 11:54:56 发布
最新推荐文章于 2022-10-17 11:54:56 发布
阅读量586 收藏
点赞数
分类专栏： 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jl19960421/article/details/117091252
版权
本文深入探讨了Java线程的六种运行状态，包括初始、运行、阻塞、等待、超时等待和终止状态，并通过代码示例展示了线程状态的验证。强调了正确终止线程的重要性，解释了`interrupt()`方法在处理阻塞线程中断时的角色，以及如何在`InterruptedException`中优雅地处理中断请求。
摘要由CSDN通过智能技术生成

深入浅出讲解java线程的运行状态

java线程的6种运行状态

  1. 初始状态(new):新创建了一个线程对象，但还没有调用start()方法。
  2. 运行状态(runnable):运行状态，JAVA线程把操作系统中的就绪和运行两种状态统一称为“运行中”。当线程对象创建成功后，当该对象的start方法被调度时，线程并不会立刻执行。而是进入一个就绪状态，等待系统调度算法的调度。当该线程获取到cpu时间片后，才会进入到运行状态。这里将“就绪状态”和“运行状态”统称为运行状态。
  3. **阻塞(blocked)状态:**是线程因为某种原因放弃了CPU使用权（线程阻塞于锁）。
  4. **等待状态(waiting)状态:**线程内调用sleep(),wait(),join(),park()方法时，就会使得线程进入到等待状态。
  5. 超时等待(time_waiting)：该状态不同于WAITING，它可以在指定的时间后自行返回。比如当线程调用sleep(long),wait(long),join(long)方法时会进入到该状态。
  6. **终止(terminated)：**表示该线程已经执行完毕。
    在这里插入图片描述

详细说明各个线程状态

1、初始状态

实现Runnable接口和继承Thread可以得到一个线程类，new一个实例出来，线程就进入了初始状态。

2、运行状态

2.1就绪状态

就绪状态只是说你资格运行，调度程序没有挑选到你，你就永远是就绪状态。
调用线程的start()方法，此线程进入就绪状态。
当前线程sleep()方法结束，其他线程join()结束，等待用户输入完毕，某个线程拿到对象锁，这些线程也将进入就绪状态。
当前线程时间片用完了，调用当前线程的yield()方法，当前线程进入就绪状态。
锁池里的线程拿到对象锁后，进入就绪状态

2.2 运行中状态

线程重新获取cpu时间片时的状态

3、阻塞状态

阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态。

4、等待状态

处于这种状态的线程不会被分配CPU执行时间，它们要等待被显式地唤醒，否则会处于无限期等待的状态。

5、超时等待

处于这种状态的线程不会被分配CPU执行时间，不过无须无限期等待被其他线程显示地唤醒，在达到一定时间后它们会自动唤醒。

6、终止状态

当线程的run()方法完成时，或者主线程的main()方法完成时，我们就认为它终止了。这个线程对象也许是活的，但是它已经不是一个单独执行的线程。线程一旦终止了，就不能复生。
在一个终止的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。

通过代码验证线程的状态

public class ThreadTest01 {
    public static void main(String[] args) {
        //time_waiting
        new Thread(() -> {
            while (true) {

                try {
                    TimeUnit.SECONDS.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            }
        }, "timewaiting").start();

        //waiting 线程在本类锁上通过wait进行等待

        new Thread(() -> {
            while (true) {
                synchronized (ThreadTest01.class) {
                    try {
                        ThreadTest01.class.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }, "waiting").start();

        //线程在ThreadTest1加锁之后，不会释放锁
        new Thread(new BlackDemo(), "black01").start();
        new Thread(new BlackDemo(), "black02").start();
    }

    static class BlackDemo extends Thread {
        @Override
        public void run() {
            synchronized (ThreadTest01.class) {
                while (true) {
                    try {
                        TimeUnit.SECONDS.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

运行上述示例，打开终端命令，输入"jps"（显示当前所有Java进程pid）；
根据获取到的pid， 通过jstack pid ，可以打印指定Java进程ID的堆栈信息
通过堆栈信息，可以看到线程的运行状态

E:threaddemo01>jps
5344 ThreadTest01
8128
8160 Jps
14596 Launcher

E:threaddemo01>jsatack 5344
'jsatack' 不是内部或外部命令，也不是可运行的程序
或批处理文件。

E:threaddemo01>jstack 5344
2021-05-20 21:05:30
Full thread dump Java HotSpot(TM) 64-Bit Server VM (25.261-b12 mixed mode):

"DestroyJavaVM" #18 prio=5 os_prio=0 tid=0x00000271325b5000 nid=0x29ec waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"black02" #17 prio=5 os_prio=0 tid=0x000002714aa74000 nid=0x2d3c waiting for monitor entry [0x000000c44c7ff000]
   java.lang.Thread.State: BLOCKED (on object monitor)
        at com.demo.ThreadTest01$BlackDemo.run(ThreadTest01.java:51)
        - waiting to lock <0x00000000d76fb2e8> (a java.lang.Class for com.demo.ThreadTest01)
        at java.lang.Thread.run(Thread.java:748)

"black01" #15 prio=5 os_prio=0 tid=0x000002714aa73800 nid=0x2804 waiting on condition [0x000000c44c6fe000]
   java.lang.Thread.State: TIMED_WAITING (sleeping)
        at java.lang.Thread.sleep(Native Method)
        at java.lang.Thread.sleep(Thread.java:340)
        at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
        at com.demo.ThreadTest01$BlackDemo.run(ThreadTest01.java:51)
        - locked <0x00000000d76fb2e8> (a java.lang.Class for com.demo.ThreadTest01)
        at java.lang.Thread.run(Thread.java:748)

"waiting" #13 prio=5 os_prio=0 tid=0x000002714a6c2000 nid=0x21f4 in Object.wait() [0x000000c44c5ff000]
   java.lang.Thread.State: WAITING (on object monitor)
        at java.lang.Object.wait(Native Method)
        - waiting on <0x00000000d76fb2e8> (a java.lang.Class for com.demo.ThreadTest01)
        at java.lang.Object.wait(Object.java:502)
        at com.demo.ThreadTest01.lambda$main$1(ThreadTest01.java:32)
        - locked <0x00000000d76fb2e8> (a java.lang.Class for com.demo.ThreadTest01)
        at com.demo.ThreadTest01$$Lambda$2/1078694789.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:748)

"timewaiting" #12 prio=5 os_prio=0 tid=0x000002714a6bd000 nid=0xd50 waiting on condition [0x000000c44c4ff000]
   java.lang.Thread.State: TIMED_WAITING (sleeping)
        at java.lang.Thread.sleep(Native Method)
        at java.lang.Thread.sleep(Thread.java:340)
        at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
        at com.demo.ThreadTest01.lambda$main$0(ThreadTest01.java:18)
        at com.demo.ThreadTest01$$Lambda$1/1324119927.run(Unknown Source)
        at java.lang.Thread.run(Thread.java:748)

"Service Thread" #11 daemon prio=9 os_prio=0 tid=0x000002714a3d2800 nid=0xcc4 runnable [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"C1 CompilerThread3" #10 daemon prio=9 os_prio=2 tid=0x000002714a303000 nid=0x2864 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"C2 CompilerThread2" #9 daemon prio=9 os_prio=2 tid=0x000002714a300000 nid=0xce0 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"C2 CompilerThread1" #8 daemon prio=9 os_prio=2 tid=0x000002714a2fc800 nid=0x3b48 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"C2 CompilerThread0" #7 daemon prio=9 os_prio=2 tid=0x000002714a2fa800 nid=0x1c78 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"Monitor Ctrl-Break" #6 daemon prio=5 os_prio=0 tid=0x000002714a2f7000 nid=0x5f8 runnable [0x000000c44bdfe000]
   java.lang.Thread.State: RUNNABLE
        at java.net.SocketInputStream.socketRead0(Native Method)
        at java.net.SocketInputStream.socketRead(SocketInputStream.java:116)
        at java.net.SocketInputStream.read(SocketInputStream.java:171)
        at java.net.SocketInputStream.read(SocketInputStream.java:141)
        at sun.nio.cs.StreamDecoder.readBytes(StreamDecoder.java:284)
        at sun.nio.cs.StreamDecoder.implRead(StreamDecoder.java:326)
        at sun.nio.cs.StreamDecoder.read(StreamDecoder.java:178)
        - locked <0x00000000d7688248> (a java.io.InputStreamReader)
        at java.io.InputStreamReader.read(InputStreamReader.java:184)
        at java.io.BufferedReader.fill(BufferedReader.java:161)
        at java.io.BufferedReader.readLine(BufferedReader.java:324)
        - locked <0x00000000d7688248> (a java.io.InputStreamReader)
        at java.io.BufferedReader.readLine(BufferedReader.java:389)
        at com.intellij.rt.execution.application.AppMainV2$1.run(AppMainV2.java:64)

"Attach Listener" #5 daemon prio=5 os_prio=2 tid=0x0000027148535800 nid=0x3034 waiting on condition [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"Signal Dispatcher" #4 daemon prio=9 os_prio=2 tid=0x0000027148520000 nid=0x2164 runnable [0x0000000000000000]
   java.lang.Thread.State: RUNNABLE

"Finalizer" #3 daemon prio=8 os_prio=1 tid=0x0000027148506800 nid=0x387c in Object.wait() [0x000000c44baff000]
   java.lang.Thread.State: WAITING (on object monitor)
        at java.lang.Object.wait(Native Method)
        - waiting on <0x00000000d7508ee0> (a java.lang.ref.ReferenceQueue$Lock)
        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:144)
        - locked <0x00000000d7508ee0> (a java.lang.ref.ReferenceQueue$Lock)
        at java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:165)
        at java.lang.ref.Finalizer$FinalizerThread.run(Finalizer.java:216)

"Reference Handler" #2 daemon prio=10 os_prio=2 tid=0x00000271484f7000 nid=0x484 in Object.wait() [0x000000c44b9fe000]
   java.lang.Thread.State: WAITING (on object monitor)
        at java.lang.Object.wait(Native Method)
        - waiting on <0x00000000d7506c00> (a java.lang.ref.Reference$Lock)
        at java.lang.Object.wait(Object.java:502)
        at java.lang.ref.Reference.tryHandlePending(Reference.java:191)
        - locked <0x00000000d7506c00> (a java.lang.ref.Reference$Lock)
        at java.lang.ref.Reference$ReferenceHandler.run(Reference.java:153)

"VM Thread" os_prio=2 tid=0x00000271484ce800 nid=0x1638 runnable

"GC task thread#0 (ParallelGC)" os_prio=0 tid=0x00000271325c9800 nid=0x6f4 runnable

"GC task thread#1 (ParallelGC)" os_prio=0 tid=0x00000271325cb000 nid=0xfc0 runnable

"GC task thread#2 (ParallelGC)" os_prio=0 tid=0x00000271325cc800 nid=0x18a4 runnable

"GC task thread#3 (ParallelGC)" os_prio=0 tid=0x00000271325cd800 nid=0x540 runnable

"GC task thread#4 (ParallelGC)" os_prio=0 tid=0x00000271325d0000 nid=0x3b68 runnable

"GC task thread#5 (ParallelGC)" os_prio=0 tid=0x00000271325d1000 nid=0x31d4 runnable

"GC task thread#6 (ParallelGC)" os_prio=0 tid=0x00000271325d4000 nid=0xe78 runnable

"GC task thread#7 (ParallelGC)" os_prio=0 tid=0x00000271325d5000 nid=0x2888 runnable

"VM Periodic Task Thread" os_prio=2 tid=0x000002714a410000 nid=0x2634 waiting on condition

JNI global references: 317

线程的终止

如何正确的终止一个线程呢？这个问题虽然看似简单，但是实际上要仔细思考。
我们知道Thread中提供了很多方法，比如stop,suspend等，这些方法可以终止一个线程或者挂起一个线程。但是这些方法不建议大家使用。原因很简单，举个例子，假设一个线程中，有多个任务在执行，此时，如果调用stop方法去强行中断，那么这个时候相当于是发送一个指令告诉操作系统把这个线程结束掉，但是操作系统的这个结束动作完成不代表线程中的任务执行完成，很可能出现线程的任务执行了一般被强制中断，最终导致数据产生问题。这种行为类似于在linux系统中执行 kill -9类似，它是一种不安全的操作。

那么除了这种方法之外，还有什么方式可以实现线程的终止呢？要了解这个问题，我们首先需要知道，一个线程什么情况下算是终止了。

一个线程在什么情况下是执行结束了

我们分析一下下面这段代码，通过start（）启动一个线程之后，本质上就是执行这个线程的run方法。那么如果这个线程在run方法执行完之前，一直处于运行状态，直到run方法中的指令执行完毕，那么这个线程就会被销毁。

public class MyThread extends Thread {
public void run() {
System.out.println("MyThread.run()");
}
}
MyThread myThread1 = new MyThread();
myThread1.start();

在正常情况下，这个线程是不需要人为干预去结束的。如果要强制结束，只能走stop这个方法。
那在哪些情况下，线程的中断需要外部干预呢？

  1. 线程中存在无限循环执行，比如while(true)循环
  2. 线程中存在一些阻塞的操作，比如sleep、wait、join等。

存在循环的线程

假设存在如下场景，在run方法中，存在一个while循环，因为这个循环的存在使得这个run方法一直无法运行结束，这种情况下，如何终止呢？

public class MyThread extends Thread {
public void run() {
while(true){
System.out.println("MyThread.run()");
}
}
}
MyThread myThread1 = new MyThread();
myThread1.start();

按照我们开发的思维来说，首先要解决的就是，while(true)这个循环，必须要有一个结束条件，其次是要在其他地方能够修改这个结束条件让该线程感知到变化。假设我们把while(true)改成while(flag)，这个flag可以作为共享变量被外部修改，修改之后使得循环条件无法被满足，从而退出循环并且结束线
程。这段逻辑其实非常简单，其实就是给了线程一个退出的条件，如果没有这个条件，那么线程将会一直运行。实际上，在Java提供了一个 interrupt 方法，这个方法就是实现线程中断操作的，它的作用和上面讲的这个案例的作用一样。

interrupt方法

当其他线程通过调用当前线程的interrupt方法，表示向当前线程打个招呼，告诉他可以中断线程的执行了，至于什么时候中断，取决于当前线程自己。
线程通过检查资深是否被中断来进行相应，可以通过isInterrupted()来判断是否被中断

public class ThreadTest02 {
    private static int i;

    public static void main(String[] args) throws InterruptedException {
        Thread thread = new Thread(() -> {
            while (!currentThread().isInterrupted()) {
                i++;
            }
            System.out.println("线程执行即将结束-----"+i);
        });
        thread.start();
        TimeUnit.SECONDS.sleep(1);
        thread.interrupt();
    }
}

这种通过标识位或者中断操作的方式能够使线程在终止时有机会去清理资源，而不是武断地将线程停止，因此这种终止线程的做法显得更加安全和优雅

处于阻塞状态下的线程被中断

另外一种情况，就是当线程处于阻塞状态下时，我想要中断这个线程，那怎么做呢？

public class ThreadTest03 {
    private static int i;

    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(()->{
           while (!Thread.currentThread().isInterrupted()){
               try {
                   TimeUnit.SECONDS.sleep(1);
                   System.out.println("线程执行中---");
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
           }
           System.out.println("------"+i);
        });
        thread.start();
        TimeUnit.SECONDS.sleep(10);
        thread.interrupt();
    }
}

结果:

线程执行中---
线程执行中---
线程执行中---
线程执行中---
线程执行中---
线程执行中---
线程执行中---
线程执行中---
线程执行中---
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at java.lang.Thread.sleep(Thread.java:340)
	at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
	at com.demo.ThreadTest03.lambda$main$0(ThreadTest03.java:18)
	at java.lang.Thread.run(Thread.java:748)
线程执行中---
线程执行中---
线程执行中---
线程执行中---
线程执行中---
线程执行中---
线程执行中---
线程执行中---

从这个例子中反馈出一个问题，我们平时在线程中使用的sleep、wait、join等操作，它都会抛出一个InterruptedException异常，为什么会抛出异常，是因为它在阻塞期间，必须要能够响应被其他线程发起中断请求之后的一个响应，而这个响应是通过InterruptedException来体现的。
但是这里需要注意的是，在这个异常中如果不做任何处理的话，我们是无法去中断线程的，因为当前的异常只是响应了外部对于这个线程的中断命令，同时，线程的中断状态也会复位。所以才会出现上方的情况，线程中断之后，导致程序抛出InterruptedException异常，之后，线程的中断状态会复位，线程继续执行。如果需要中断，则还需要在catch中添加下面的代码

public class ThreadTest03 {
    private static int i;

    public static void main(String[] args) throws InterruptedException {
        Thread thread=new Thread(()->{
           while (!Thread.currentThread().isInterrupted()){
               try {
                   TimeUnit.SECONDS.sleep(1);
                   System.out.println("线程执行中---");
               } catch (InterruptedException e) {
                   e.printStackTrace();
                   //响应中断，再次中断。
                   Thread.currentThread().interrupt();
               }
           }
           System.out.println("------"+i);
        });
        thread.start();
        TimeUnit.SECONDS.sleep(10);//这里还有一种情况，如果这里的睡眠时间很短，导致线程在执行while (!Thread.currentThread().isInterrupted())语句之前，就执行中断的命令 thread.interrupt()，那么程序就会立刻中断，不会执行while语句中的程序。中断状态也不会复位。
        thread.interrupt();
    }
}


线程执行中---
线程执行中---
线程执行中---
线程执行中---
线程执行中---
线程执行中---
线程执行中---
线程执行中---
线程执行中---
java.lang.InterruptedException: sleep interrupted
	at java.lang.Thread.sleep(Native Method)
	at java.lang.Thread.sleep(Thread.java:340)
	at java.util.concurrent.TimeUnit.sleep(TimeUnit.java:386)
	at com.demo.ThreadTest03.lambda$main$0(ThreadTest03.java:18)
	at java.lang.Thread.run(Thread.java:748)
------0

所以，InterruptedException异常的抛出并不意味着线程必须终止，而是提醒当前线程有中断的操作发生，至于接下来怎么处理取决于线程本身，比如

  1. 直接捕获异常不做任何处理
  2. 将异常往外抛出
  3. 停止当前线程，并打印异常信息

本篇文章参考原文链接：https://blog.csdn.net/pange1991/article/details/53860651

沐谦
关注
专栏目录
浅谈Java线程状态
Guilai1990的博客
01-06 271
本文章基于JDK8版本 从官方文档看，Java线程有6种状态，分别为NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED，在类Thread中有更详尽的对于线程状态描述，如下代码所示 /** * A thread state. A thread can be in one of the following states: * &...
java 线程一直运行状态_详解JAVA 线程-线程的状态有哪些？它是如何工作的？
weixin_39928736的博客
02-16 700
线程(Thread)是并发编程的基础，也是程序执行的最小单元，它依托进程而存在。一个进程中可以包含多个线程，多线程可以共享一块内存空间和一组系统资源，因此线程之间的切换更加节省资源、更加轻量化，也因此被称为轻量级的进程。线程的状态在 JDK 1.5 之后以枚举的方式被定义在 Thread 的源码中，它总共包含以下 6 个状态：NEW，新建状态，线程被创建出来，但尚未启动时的线程状态；RUNNABL...
使用java自带工具监控jvm运行状态
12-22
1.jps：查看当前运行着的java进程（仿linux下的ps），显示进程号 　　2. jinfo: 查参数jinfo -flagPermSize 2208(进程号) jinfo -flag MaxPermSize 2208(进程号) C:UsersWILL>jinfo Usage: jinfo (to connect to a running process) where is one of: -flag          to print the value of the named VM flag -flag
java 监控txt_java监控文件运行状态
weixin_30234101的博客
02-13 104
package com.rmi.clent;import java.io.FileNotFoundException;import java.io.IOException;import java.io.RandomAccessFile;import java.nio.channels.FileChannel;import java.nio.channels.FileLock;import java...
java 进程运行状态图解
weixin_34110749的博客
04-08 437
原文博客地址https://www.cnblogs.com/GooPolaris/p/8079490.html java中进程的状态有 6 种:NEW(新建)、RUNNABLE(运行)、BLOCKED(锁池)、TIMED_WAITING(定时等待)、WAITING(等待)、TERMINATED(终止、结束)，一般还会有阻塞状态，可运行状态，挂起状态。 一般线程转换图 j...
Java线程状态
10-31 149
下面是Java线程的状态图  1、创建状态 当我们通过new操作符创建一个新的线程对象时，该线程处于创建状态。此时，它已经有了相应的内存空间和其它资源，但还处于不可运行状态，通过调用start方法进入就绪状态。 注意：不能对已经启动的线程再次调用start()方法，否则会出现java.lang.IllegalThreadStateException异常   2、就绪状态 处于就绪状...
java线程的运行状态
qq_42572415的博客
01-26 196
NEW(新建状态):线程刚被创建,但是并未启动 Runnable(可运行状态):线程可以在java虚拟机中运行的状态,可能正在运行自己代码,也可能没有,取决于操作系统处理器. Blocked(锁阻塞状态):当一个线程试图获取一个对象锁，而该对象锁被其他的线程持有，则该线程进入Blocked状态；当该线程持有锁时，该线程将变成Runnable状态。 Waiting(无线等待):一个线程在等待另...
深入浅出java
11-14
《深入浅出Java》这本书以其独特的讲解方式，旨在让学习者轻松掌握复杂的Java编程语言。"深入浅出"这一理念，意味着作者通过直观、生动的示例和丰富的图解，帮助读者逐步理解Java的核心概念和技术。 Java是一种广泛...
java线程入门教程,涉及线程基本知识，显浅易懂．.zip
最新发布
04-24
本教程中的"java线程入门教程,涉及线程基本知识，显浅易懂．"文件将详细讲解这些概念，并通过示例代码帮助读者理解和实践。"1-2论坛"可能包含了一些讨论和问题解答，可以帮助你解决学习过程中遇到的困惑。通过学习这...
深入浅出理解Java并发AQS的共享锁模式
Huangjiazhen711的博客
10-17 481
首先我们通过AQS实现一个非常最最最轻量简单的共享锁例子，帮助大家对共享锁有一个整体的感知。@Slf4j/*** 共享锁帮助类*//*** 创建共享锁帮助类，最多有count把共享锁，超过了则阻塞** @param count 共享锁数量*/}/*** 尝试获取共享锁** @param arg 每次获取锁的数量* @return 返回正数，表示后续其他线程获取共享锁可能成功；返回0，表示后续其他线程无法获取共享锁；返回负数，表示当前线程获取共享锁失败*/
java 多线程编程实战指南（核心 + 设计模式 完整版）
03-20
《Java多线程编程实战指南》这本书深入浅出地讲解了Java多线程的核心概念和实战技巧，分为核心篇和设计模式篇，旨在帮助开发者掌握并应用多线程技术。 1. **线程基础** - **线程的创建**：Java提供了两种创建线程...
深入浅出吃透多线程、线程池核心原理及代码详解
Linuxhus的博客
07-07 226
一、多线程详解 　　1、什么是线程 　　线程是一个操作系统概念。操作系统负责这个线程的创建、挂起、运行、阻塞和终结操作。而操作系统创建线程、切换线程状态、终结线程都要进行CPU调度——这是一个耗费时间和系统资源的事情。 腾讯认证T9后端开发岗位，linux服务器开发高级架构师系统学习视频点击：C/C++Linux服务器开发高级架构师/Linux后台架构师 B站7000+播放的线程池视频讲解：150行代码，手写线程池（完整版） 　　2、线程生命周期 　线程通常都有五种状态，创建、就绪、运行
JAVA线程运行状态
jdassd的博客
07-15 392
JAVA线程运行状态
Kieker初探：获取普通Java程序运行状态
小菜鸡的博客
01-13 641
这篇笔记里简单总结一下使用Kieker获取普通Java程序运行状态的步骤，希望对初学的朋友有所帮助。
java 线程运行状态讲解
weixin_38368556的博客
07-10 226
通过查看java1.8 Thread 类的源码，Java 线程状态一共分为5类： 1，new ： 新建状态，这个线程表明线程刚刚创建还没有运行。 2，runnable：一个能够运行的线程状态，处与这个状态的线程 有可能正在jvm内部被执行，也有可能正在等待操作系统的调度。 3，blocked：阻塞状态，处于该状态的线程 正在等待一个synchronized 同步所，或这已经进入一个synch...
java线程的状态及操作方法
cjc211322的专栏
05-05 1020
java线程状态以及线程的操作方法
java程序执行时在内存中的状态_Java程序运行时内存划分
weixin_28990495的博客
02-25 128
1.Java程序跨平台运行的原因主要原因是：各种平台的JVM和字节码文件Java源程序--具体平台的机器代码文件---被编译器翻译成平台无关的Class文件，又用特定JVM运行字节码文件，JVM在运行的过程中将字节码指令转换为具体平台的机器指令。JVM运行在用户态，操作系统将JVM看作是一个特殊的软件，JVM启动的时候，OS给其划分一定的内存供其运行字节码文件。存在基于JVM的其他编程语言的原因：...
Java线程运行轨迹-代码追踪与定位
weixin_30550271的博客
05-07 319
今天在写程序时，想到一个问题，当我的程序出异常的时候，控制台输出信息中，明确指出了出现异常的位置，并详细列举了函数的调用层次关系，它是怎么做到的。 竟然想到了这个问题，就去查看了源代码，不过没点几下，就遇到了native本地方法，只好作罢。于是又去网上找了这方面的资料，最后找到了一点这方面的东西，不过它给出的只是API，却并没有对代码做什么解释。代码如下 public clas...
一张图带你看懂java线程运行的七种状态
u012485165的博客
08-02 1039
 
Android开发入门指南：深入浅出Android解析
资源"深入浅出Android开发：一本全面解析Android开发的入门书籍，旨在帮助初学者和有经验的开发者深入理解Android系统的工作原理和开发技巧。该资源来源于www.eoeandroid.com，这是一个知名的Android开发社区，提供...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值