Thread常用的方法及线程状态原因解析

于 2024-03-30 22:40:27 发布
阅读量1.2k 收藏 15
点赞数 47
分类专栏： JavaEE初阶 文章标签： java jvm java-ee
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_77053417/article/details/137127179
版权

温馨提示：PC端观看，效果更佳！

本文两大部分：介绍一些Thread线程常用的方法，和解析线程的六大状态！

目录

一、线程常用的方法

介绍Thread类

1.开启线程

2.获取线程引用

3.休眠线程

4.中断线程

3.等待线程

二、线程状态

1.NEW

2.TERMINATED

3.RUNNABLE

4.WAITING

5.TIMED_WAITING

6.BLOCKED

7.状态总结(超级重要)

一、线程常用的方法

介绍Thread类

（1）这是一个线程类，用来实例化线程对象

（2）该类中，有很多方法。普通成员方法，可以使用对象的引用进行调用，像statr()方法等等；而静态方法，则需要通过类名去调用，如：Thread.sleep()等等。

（3）我们通过Thread来实例化对象，产生的对象，我们默认称为“线程对象”，start()之后，线程才产生。因此，类中拥有的各种属性方法，我们后面就默认称为该线程的属性和方法。

（4）线程，有哪些状态、属性，方法，本质上都是Thread中的；因此我们实例化出的线程，也就具有了。后续所说的线程，都是指 线程对象

1.开启线程

（1）方法：start()

（2）作用：当线程对象调用该方法之后，真正的线程才真正的被创建出来并且执行。

（3）实例

 public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread("张三线程") {
            @Override
            public void run() {
                System.out.println("111");
            }
        };
        t.start();
    }

在：该操作，只是创造出了线程对象

Thread t = new Thread("张三线程")

只有：start()之后，该线程才是真正创建并运行了起来(真正在系统中创造了PCB)

 t.start();

（4）start()注意事项

每一个线程对象，只可以start()一次。第二次start()操作就会出现异常

异常：非法的线程状态 

该线程状态：

原因：线程start()之后，被调度到cpu上执行，当线程中的任务执行完之后，就会被销毁了；此时线程(PCB)已经不存在了，但是Thread对象(t引用指向的对象)还存在。

2.获取线程引用

（1）作用：返回当前线程对象的引用(在哪个线程中调用，就返回哪个线程的)

（2）方法全貌：public static native Thread currentThread()

（3）返回自定义线程的引用

public static void main(String[] args) {
        Thread t = new Thread(()->{
            System.out.println(Thread.currentThread().getState());
            System.out.println("开启线程成功！");
        }) {
        };
        t.start();
    }

获取t线程的引用，并且调用该线程的状态

（4）获取主线程的引用

 public static void main(String[] args) {
        Thread t = Thread.currentThread();//此时t中存的是main线程的引用
        System.out.println("线程名字："+t.getName());
    }

3.休眠线程

（1）方法:Thread.sleep()。很明显，这是一个静态方法，需要传参。

参数是整数，单位是ms。1000ms等于一秒

（2）作用：让线程休眠

（3）实例

public static int m = 4;
    public static void main(String[] args) {
        Thread t = new Thread(()->{
            while (true) {
                try {
                    Thread.sleep(1000);
                    m--;
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println(m+"秒后结束t线程");
                if(m == 1) break;
            }
            System.out.println("t线程结束");
        });
        t.start();
    }

作用：每循环一次，就会休眠一秒，当休眠三秒后，线程就会结束。

（4）使用的注意实现1

1）在重写的run方法中

原因：在方法重写的时候，要求方法前面是一样的，run方法的父类是没有抛出异常的，所以run方法也不能抛出异常。所以sleep异常处理选择时，就不能抛出异常，只能捕获异常。

2）在外面

（5）sleep的注意事项2

sleep控制的是线程的休眠时间，而不是两个代码之间的时间

在时间上，并不是1000ms.

得出一个小结论：sleep结束之后，线程不一定会马上被调度会cpu上执行。

4.中断线程

更加合理的说法是说，终止一个线程。按理来说，当线程开启的时候，就会一直执行，直到线程的任务结束。但是有时候，需要停止线程，就需要一些操作去执行了。而终止线程，只是起到提醒的作用，线程是否要终止，还要看线程本身。

目前有两种方式：

（1）通过共享的标记来进行沟通（2）调用interrupt()方法来通知

2.1.第一种实现

（1）标志正确写法

    public static boolean isRunning = true;
    public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while (isRunning) {
                System.out.println("线程正在执行！");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println("线程结束了");
        });
        t.start();
        System.out.println("3s后结束线程");
        Thread.sleep(1000);
        isRunning = false;
    }

实现手段：通过改变循环的条件来终止循环，进而结束线程。

（2）缺点

1）该标志变量要定义在main方法外面，也就是全局变量；如果定义在里面，会被内部类捕获到，从而报错。

2）这种终止线程写法的缺点 ，即使循环条件不符合了，需要结束循环，但是由于上一次循环进入时，线程正在sleep中，导致无法即使终止线程。

2.2.第二种实现

（1）简介：使用Thread的三个方法来配合实现。下面介绍

方法作用
public void interrupt()修改标志位(哪个线程调用就修改)
public static native Thread currentThread()获取当前线程的引用
public boolean isInterrupted()线程中自带的标志位，默认值为false

（2）代码实现

 public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("线程正在执行！");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
            System.out.println("线程结束了");
        });
        t.start();
        System.out.println("3s后结束线程");
        Thread.sleep(1000);
        t.interrupt();

    }

代码是结束了，但是抛出了异常。是因为唤醒sleep等阻塞的方法，即使线程在sleep中，也能即使结束线程（就是相比于第一种方法的优势）。设置成false之后，则会让sleep抛出一个InterruptedException异常，不需要等待sleep，进而结束了。

如果更改sleep抛出的异常，进而可以控制线程。

（3）提醒线程终止，但是不想结束

 public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("线程正在执行！");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //throw new RuntimeException(e);
                    e.printStackTrace();
                }
            }
            System.out.println("线程结束了");
        });
        t.start();
        System.out.println("3s后结束线程");
        Thread.sleep(1000);
        t.interrupt();
    }

代码没有结束，抛出一个异常后继续执行了代码。

原因：在触发interruptd的时候，而线程正在sleep的时候，会唤醒正在sleep，并且把interrupt修改的标志位又修改回来(又改回false)。前面因为没有修改抛出的异常，而直接把线程终止了。

（4）提醒线程终止，马上终止

 public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("线程正在执行！");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    //throw new RuntimeException(e);
                    //e.printStackTrace();
                    System.out.println("自愿结束线程");
                    break;
                }
            }
            System.out.println("线程结束了");
        });
        t.start();
        System.out.println("3s后结束线程");
        Thread.sleep(1000);
        t.interrupt();
    }

（5）提醒线程终止，等会结束

public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("线程正在执行！");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println("我先打印完1234再结束");
                    System.out.println(1);
                    System.out.println(2);
                    System.out.println(3);
                    System.out.println(4);
                    break;
                }
            }
            System.out.println("线程结束了");
        });
        t.start();
        System.out.println("3s后结束线程");
        Thread.sleep(1000);
        t.interrupt();
    }

3.等待线程

等待线程有三个重载的方法，前面的两个比较常用

方法说明
public void join()等待线程结束(死等)
public void join(long millis)等待线程结束，最多等millis毫秒
public void join(long millis,int nanos)同2，但可以更高精度(因此容易出错)

线程等待的意义：多线程中，调度顺序是无序的，因此每个线程的执行时间和结束时间是不确定的。引用线程等待，就可以控制线程结束的先后顺序

下面以join()为主要介绍。

3.1.join()

（1）没有等待时

 public static void main(String[] args)  {
        Thread t = new Thread(()->{
           while (true) {
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
               System.out.println("t");
           }
        });
        t.start();
        System.out.println("main线程");
    }

此时，是main线程已经结束，但是t线程没有结束。

（2）引入等待

 public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
           while (true) {
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
               System.out.println("t");
           }
        });
        t.start();
        t.join();
        System.out.println("main线程");
    }

通过代码的结果可以看到，没有执行后面的打印语句。这样的意思是：main线程需要等待t线程结束后才能结束，也就是结束t.join()语句才行。

此时，main线程在等待t线程，也就是等待状态。代码无法直接观看，借助调用栈来观看

（3）等待解析

哪个线程调用join，哪个线程就是要先执行结束的。准确的来说：在A线程里面，B线程调用join，那么线程结束的顺序就是 B-->A，也就是线程A会等待线程B先结束

（4）深入理解

上面的代码中，在main中调用t.join()，有三种情况。

1）如果线程t此时已经结束了，此时的join就会立即返回，相当于join没气作用

2）如果线程t还没结束，此时main线程就会阻塞等待t线程结束，直到t线程结束之后，join才会解除阻塞，继续执行main

3）当执行t.join时，t线程还没开始，就会直接跳过t.join()，相当于没起到作用

下面介绍上面三种情况，顺便多介绍两种情况。

第一种情况：t.join时，t线程已经结束了(只有t线程和main线程)

当代码执行到t.join()时，t线程已经被销毁了，所以执行join时就直接返回了，相当于没有

第二种情况：正常起到作用(只有t线程和main线程)

当执行到t.join()时，t线程还没结束，此时就会main线程就会阻塞等待，直到t线程结束之后才会继续执行

第三种情况：t线程还没开始(只有t线程和main线程)

这就是当执行到t.join()时，t线程还没开始执行

第四种情况：三个线程嵌套等待(t1线程、t2线程、main线程)

预期结束顺序：t2 -> t1 -> main 

 public static void main(String[] args) throws InterruptedException {
        Thread t2 = new Thread(()->{
            for (int i = 0; i < 3; i++) {
                System.out.println("t2");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        Thread t1 = new Thread(()->{
            try {
                Thread.sleep(500);//确保t2线程此时已经启动
                t2.join();//t1线程阻塞等待t2线程结束后再执行
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            for (int i = 0; i < 3; i++) {
                System.out.println("t1");
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
            }
        });
        t1.start();
        t2.start();

        t1.join();//main线程阻塞等待t1线程结束再继续执行
        System.out.println("main end");
    }

得出一个小结论：在A线程中使用B.join()，那么一定是B线程先结束，A线程后结束(join阻塞A线程)；但是A线程中同时使用B.join()和C.join()，B线程和C线程之间是并发执行，A阻塞等待的时间是Math.max(B线程的时间，C线程的时间)

执行结果：

第五种情况：main线程也可以join()操作

要想做到main线程先结束，就要拿到主线程的引用

public static void main(String[] args) throws InterruptedException {
        Thread mainT = Thread.currentThread();//拿到main线程的引用
        System.out.println(mainT.getName());

        Thread t = new Thread(()->{
            try {
                mainT.join();//main线程先结束，t线程才会继续执行
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
            System.out.println("t end");
         });
        t.start();
        Thread.sleep(2000);
        System.out.println("main end");
    }

由此可见，main线程也是可以join的

由于join()是一个死等的方法，只有t线程不结束，还没的代码就不会执行。这种写法很不友好。

3.2.join(long millis)

（1）这是一种带有时间的等待，参数就是需要等待的时间，如果超过了这个时间就不会继续执行下去，进而去执行后面的代码。

 public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
           while (true) {
               try {
                   Thread.sleep(1000);
               } catch (InterruptedException e) {
                   throw new RuntimeException(e);
               }
               System.out.println("t");
           }
        });
        t.start();
        t.join(3000);
        System.out.println("main end");
    }

t线程是一个死循环线程，永远不会结束，如果是死等的join，那么main线程永久不会结束。但是这是一个带有时间的超时等待，过了这个时间就不会再继续等待下去

（2）如果join等待3秒，而t线程执行2秒，也会提前结束join，并不是真的会等待3秒

4.方法小结(超级重要)

注：方法括号中的ms代表毫秒

方法名称方法方法作用
开始一个线程start()自定义的线程调用后，才代表该线程启动
获取当前线程的引用currentThread()可以获取当前线程的一个引用
休眠线程sleep(ms)让当前线程休眠指定时间
中断线程isInterrupted()、interrupted()提醒线程是否要终止
等待线程join()--无参方法调用该方法的线程提前结束，阻塞
join(ms)--带有参数方法在嵌套该线程的那个线程

 

二、线程状态

线程的状态，也是PCB中的状态。粗分的话有四个状态，细分是六个状态。下面我们以六个状态来介绍。

状态名字
NEW新建状态
TERMINATED终止态
RUNNABLIE就绪态
WAITING死等状态
TIMED_WAITING带有超时时间的等待
BLOCKED因锁竞争的阻塞

后面三种，大的方向都是阻塞状态

下面每个状态一一介绍，产生状态的原因。每种状态都会用代码使用，和在调用堆栈中观察，如果可以使用代码观察(使用getState()查看线程状态)，也会一起展示。

1.NEW

（1）小写：new  中文名字：新建态

（2）产生时间/原因：在Thread对象产生后，为start()之前

（3）线程状态解释：此时的线程并未真正的产生，只存在硬盘中，当start()后，线程才真正产生（处于cpu上）

（4）代码观察状态

public static void main(String[] args) {
       Thread t = new Thread();
       System.out.println(t.getState());
}

（5）使用调用堆栈观看

 public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread("ttttt");
        System.out.println(t.getState());
        Thread.sleep(30000);
    }

让main线程休眠30秒，好让观察

此时，只能看到main线程，而看不到ttttt线程，原因就是此时只是创造出Thread对象，线程处于新建态，还未调度到cpu上执行

2.TERMINATED

（1）小写：terminated  中文：终止态

（2）产生原因：线程开始后，线程完成了任务之后，线程从pcb中被销毁

（3）代码观察

1）第一种

public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            System.out.println("执行完这个语句t线程就结束");
        });
        System.out.println(t.getState());
        t.start();
        Thread.sleep(3000);
        System.out.println(t.getState());
    }

等待三秒后再去获取t线程的状态

2）第二种实现

 public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            System.out.println("执行完这个语句t线程就结束");
        });
        System.out.println(t.getState());
        t.start();
        t.join();
        System.out.println(t.getState());
    }

使用t.join()，就可以保证在t线程结束之后再去执行后面的语句(推荐)

（4）使用调用堆栈观察

使用堆栈无法观察，因为这个状态是线程终止态，线程已经被销毁了，不复存在。

3.RUNNABLE

（1）小写：runnable  中文：就绪状态

（2）产生原因有两种

1）这个线程正在CPU上执行

2）这个线程不在CPU上执行，但是可以随时调度到CPU上执行

下面我们只去研究第一种，因为第二种我们无法干预，也无法展示

（3）代码观察

 public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            try {
                Thread.sleep(20000);
            } catch (InterruptedException e) {
                throw new RuntimeException(e);
            }
        });
        System.out.println(t.getState());
        t.start();
        System.out.println(t.getState());
    }

此时线程还是休眠中，任务还没结束，因此展示出来的就是RUNNABKE

（4）在调用堆栈中

 public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
           while (true) {

           }
        });
        System.out.println(t.getState());
        t.start();
        System.out.println(t.getState());
    }

在t线程中，我们使用死循环的写法。如果是休眠时间，但调用堆栈中会是：带有超时时间的等待状态。

4.WAITING

（1）小写：waiting  名称：等待

（2）原因：由于死等进入的等待状态。其中有两个典型的例子

1）由于join()进入的死等状态  

2）由于wait()进入的死等状态（在线程安全问题部分会有学习）

（3）因join()进入的WAITING状态

由于要执行完t.join()才会去执行后面的语句，所以代码层面观察不到线程的状态

 public static void main(String[] args) throws InterruptedException {
        Thread t = new Thread(()->{
            while (true) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    throw new RuntimeException(e);
                }
                System.out.println("1");
            }
        });
        t.start();
        t.join();
        System.out.println(Thread.currentThread().getState());

    }

使用调用堆栈观察：

（4）因wait()进入的等待状态

这个方法居然做什么的，目前先不做具体的解释

可见，线程的WAITING状态是由于两种死等的方法造成的

5.TIMED_WAITING

（1）名称：带有超时时间的等待

（2）产生原因：由带参数的：join()、sleep()、waiting()方法而进入的带有超时时间的等待。

（3）第一种：由sleep()进入的等待

（4）第二种：带有时间的join()

（5）第三种：带有时间的wait()

以上就是进入TIMED_WAITING状态的三种方式

6.BLOCKED

（1）原因由来：由于锁竞争产生的阻塞

（2）代码展示

public static void main(String[] args) {
        String str = "520";
        Thread t1 = new Thread(()->{
            synchronized (str) {
                while (true) {
                }
            }
        });
        t1.start();
        Thread t2 = new Thread(()->{
            synchronized (str) {
                System.out.println("1");
            }
        });
        t2.start();
        System.out.println(t2.getState());
    }

由于t1线程已经对str对象上锁，当t2再次想对str对象加锁时，就会产生互斥，从而进入阻塞状态。

7.状态总结(超级重要)

7.1.部分总结

（1）RUNNABLE状态

原因1：这个线程正在cpu上执行，也就是线程正在执行

原因2：这个线程暂时未在cpu上执行，但是可以随时调度到cpus上执行

（2）阻塞状态

阻塞状态的作用：进入阻塞状态的线程，暂时不能调度到cpu上执行，直到满足一定的条件，才会重新进入就绪状态。

阻塞状态有三个：WAITING、TIMED_WAITING、BLOCKED

三种状态都是阻塞状态，但是产生的原因不一样

7.2.表格总结

 

状态产生原因1产生原因2产生原因3
NEWThread对象创建时
TERMINATED内核中的线程(PCB)被销毁(线程结束时)
RUNNABLE线程正在cpu上运行时线程可以随时调度到cpu运行（不可干预）
WAITINGjoin()wait()
TIMED_WAITINGsleep(参数)join(参数)wait(参数)
BLOCKED对同一个锁竞争

代码小娥
关注
  • 47
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 4
    评论
专栏目录
理解Python并发编程一篇就够了 - 线程篇
qq_27009517的博客
09-21 715
前言 对我来说，编程的乐趣之一是想办法让程序执行的越来越快，代码越写越优雅。在刚开始学习并发编程时，相信你它会有一些困惑，本文将解释多个并发开发的问题并帮助你快速了解并发编程的不同场景和应该使用的解决方案。 GIL Python（特指 CPython）的多线程的代码并不能利用多核的优势，而是通过著名的全局解释锁（GIL）来进行处理的。如果是一个计算型的任务，使用多线程 GIL 就会让多线程变慢。我们举个计算斐波那契数列的例子： # coding=utf-8 import time i...
知识点三：线程(Thread)的状态有哪些？它的工作原理及常用方法
latata的博客
03-21 717
线程（Thread）是并发编程的基础，也是程序执行的最小单元，它依托进程而存在。一个进程中可以包含多个线程，多线程可以共享一块内存空间和一组系统资源，因此线程之间的切换更加节省资源、更加轻量化，也因此被称为轻量级的进程。 线程的状态在 JDK 1.5 之后以枚举的方式被定义在 Thread 的源码中，它总共包含以下 6 个状态： NEW，新建状态，线程被创建出来，但尚未启动时的线程状态； RUN...
线程的6种状态
u011649691的博客
09-18 331
/** * A thread state. A thread can be in one of the following states: * <ul> * <li>{@link #NEW}<br> * A thread that has not yet started is in this state. ...
Thread 状态详解
slow is fast
01-09 254
原文：http://www.cnblogs.com/DreamSea/archive/2012/01/11/JavaThread.html  不废话直接上图： 1）优先级（priority） 每个类都有自己的优先级，一般property用1-10的整数表示，默认优先级是5，优先级最高是10；优先级高的线程并不一定比优先级低的线程执行的机会高，只是执行的机率高；默认一个线程的优先级和创建...
Thread状态
weixin_34026484的博客
05-17 70
转载于:https://www.cnblogs.com/cxhfuujust/p/10880003.html
Java多线程状态及方法实例解析
08-25
Java多线程状态及方法实例解析 Java多线程状态及方法实例解析是Java多线程编程的核心内容，对Java程序员来说非常重要。多线程状态是指线程在不同的生命周期中所处的状态，而方法实例解析则是对多线程编程的具体实现...
Java多线程-Thread类的常用结构及线程优先级
最新发布
01-27
本文将详细解析Thread类的常用结构以及线程优先级。 一、Thread类的常用结构 1. 线程中的构造器 - `Thread()`：创建一个没有指定名称的新线程对象。在创建Thread类的子类时，如果子类没有提供构造器，会默认调用...
Java Thread多线程全面解析
09-02
Java Thread多线程全面解析涵盖了Java编程中关于线程的重要概念和实践技巧。在Java中，多线程是并发编程的基础，允许程序同时执行多个任务，提高系统资源利用率和应用程序的响应速度。 线程的生命周期包括五个基本...
浅谈Java线程Thread之interrupt中断解析
08-28
Java线程Thread之interrupt中断解析 Java线程Thread之interrupt中断机制是Java多线程编程中的一种重要机制。通过调用Thread.interrupt()方法，可以设置线程的中断状态位，线程会不时地检测这个中断标示位，以判断...
Java线程的相关方法详细解析
09-05
下面将对Java线程的主要方法进行详细解析： 1. **start()** - 这个方法是启动线程的关键，当你创建了一个`Thread`对象后，必须调用`start()`方法来启动它。这个方法会调用线程的`run()`方法，但区别在于`start()`会...
Thread（线程)的五种状态
qq_32441071的博客
06-22 1358
一.线程的五种状态 创建，就绪，运行，挂起（包括阻塞，睡眠，等待），结束 1.创建 一个被创建的线程，但是还没有执行线程类的start（）方法来启动线程。 2.就绪 调用线程的start（）方法后，其实线程进入了就绪状态，切记，并非直接进入运行状态。 3.运行 当处于就绪状态的线程获得时间片后，就进入了运行状态。 4.挂起 挂起是我认为在线程运行状态中最复杂的一个环节，它分为睡眠，等待（又包括超时...
Thread 运行状态
weixin_34347651的博客
03-08 409
2019独角兽企业重金招聘Python工程师标准>>> ...
03- 线程的状态有哪些？它是如何工作的？
深海的鱼
04-05 411
线程（Thread）是并发编程的基础，也是程序执行的最小单元，它依托进程而存在。一个进程中可以包含多个线程，多线程可以共享一块内存空间和一组系统资源，因此线程之间的切换更加节省资源、更加轻量化，也因此被称为轻量级的进程。 线程的状态在 JDK 1.5 之后以枚举的方式被定义在 Thread 的源码中，它总共包含以下 6 个状态： NEW，新建状态，线程被创建出来，但尚未启动时的线程状态； RUN...
Thread 状态&方法
04-20 109
线程状态 源码中可以看到关于线程的状态有一下几种： public enum State { NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED; } 状态图示 下图展示线程执行过程中状态的切换 常见方法 1.sleep：释放cpu， 不释放锁， Thread类的方法，必须带一个时间参数。 2.yield：让出CPU调度，重新回到可执行状态， 参与锁的竞争，Thread类的方法。 3.wait
Java Thread 状态机
来啊 快活啊
08-06 296
Thread#sleep、thread#wait和thread#join被其他线程thread#interrupt()之后，会抛出 InterruptedException;需要在线程中处理InterruptedException； LockSupport.park() 方法不回抛出InterruptedException，程序继续往下执行； 参考 Java线程Thread的状态解析以及状态转换分析 多线程中篇（七） Java面试：线程状态机 ...
Thread详解3：线程的状态及几个简单方法
cds86333774的博客
03-27 5321
1 线程状态类型 新建状态（New）：新创建了一个线程对象。 就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。 运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。 阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才
Thread线程互斥&线程安全&线程的六种状态
Menfolk_k的博客
07-29 140
线程互斥 //线程等待 synchronized(锁对象){ //要保护的代码,作为原子的整体执行,(只能有一个线程执行,当这个线程执行时,其他线程都在synchronized处等待其他线程执行完毕 } //等待锁内线程执行完毕后会释放锁,其他等待的线程再去争抢锁对象,是有线程能够进入锁对象 // 加锁时一定要注意加的锁是否为同一把锁 synchronized关键字的两种方法 加在普通方法上 public synchronized void method(){ //这时 synchro
Thread的6种状态
icepigeon314
06-22 2066
Thread类中有一个State的枚举类型，定义了6种状态，源码如下： 各个状态之间是可以相互转换的，状态图如下： 为了加深Thread状态的理解，下面写了个测试程序，代码和结果如下： public class ThreadTest { public static void main(String[] args) { final Object obj...
【多线程初阶】Thread类常见方法以及线程的状态
一些普普通通的学习笔记
07-13 653
本文是属于多线程初阶内容系列的, 如果还没有学习过之前文章的, 请先移步博主的之前的文章进行学习, 本文就是在学会线程的创建后, 再带大家认识一下 Thread 类以及其常见的方法, 再给大家讲解一下线程都有哪些状态.
Java 多线程与并发(2-26)Java 并发 - 线程基础.pdf
07-14
Java 多线程与并发(2_26)Java 并发 - 线程基础

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

代码小娥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值