一文读懂Java线程状态转换

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了一文读懂Java线程状态转换，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含13170字，纯文字阅读大概需要19分钟。

内容图文

主要以代码示例说明线程状态如何转换。

基础知识

1. 线程状态

线程可以有6种状态：

New（新建）
Runnable（可运行）
Blocked（被阻塞）
Waiting（等待）
Timed waiting（计时等待）
Terminated（被终止）

New：new Thread()后线程的状态就是新建。
Runnable：线程一旦调用start()方法，无论是否运行，状态都为Runable，注意Runable状态指示表示线程可以运行，不表示线程当下一定在运行，线程是否运行由虚拟机所在操作系统调度决定。
被阻塞：线程试图获取一个内部对象的Monitor（进入synchronized方法或synchronized块）但是其他线程已经抢先获取，那此线程被阻塞，知道其他线程释放Monitor并且线程调度器允许当前线程获取到Monitor，此线程就恢复到可运行状态。
等待：当一个线程等待另一个线程通知调度器一个条件时，线程进入等待状态。
计时等待：和等待类似，某些造成等待的方法会允许传入超时参数，这类方法会造成计时等待，收到其他线程的通知或者超时都会恢复到可运行状态。
被终止：线程执行完毕正常结束或执行过程中因未捕获异常意外终止都会是线程进入被终止状态。

2. 线程状态转换

线程从“新建”到“被终止”会历经多次状态转换，所有可能的转换如下图：

一文读懂Java线程状态转换 - 文章图片

【图一】

观察状态转化图，我们发现“可运行”状态为所有状态的必经状态。我们分析出四条基本的状态转换线路图。

新建--->可运行--->被终止
新建--->可运行--->被阻塞--->可运行--->被终止
新建--->可运行--->等待--->可运行--->被终止
新建--->可运行--->计时等待--->可运行--->被终止

“新建”和“被终止”状态分别为起始和结束状态，和“可运行”状态不可逆。其他状态均能和“可运行”状态相互转换。

用代码说话

让我们用代码演示线程状态是如何转换的，大家重点关注两个问题？

什么操作会改变线程状态？
改变的状态是如何恢复的？

一、新建--->可运行--->被终止

这个状态转换时创建的线程生命周期。

/**
 * NEW->RUNNABLE->TERMINATED
 */
public class ThreadStateNRT {

    public static void main(String[] args) {
        Thread thread=new Thread(new Task());
        print(thread.getName(),thread.getState());
        thread.start();
        //等待线程执行完毕。
        try {
            thread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        print(thread.getName(),thread.getState());
    }

    private static class Task implements Runnable{
        @Override
        public void run() {
            print(Thread.currentThread().getName(),Thread.currentThread().getState());
        }
    }
    private static final String stringFormat="%s:%s";
    private static void print(String threadName,Thread.State state){
        System.out.println(String.format(stringFormat,threadName,state));
    }
}

其中，print()方法用来打印线程信息。后面的代码示例均不在展示。

运行程序结果为：

Thread-0:NEW
Thread-0:RUNNABLE
Thread-0:TERMINATED

二、新建--->可运行--->被阻塞--->可运行--->被终止

只有一种方法能出现阻塞状态，那就是synchronized同步原语。我们需要两个线程其中一个线程被另一个阻塞来展示。

/**
 * NEW->RUNNABLE->BLOCKED->RUNNABLE->TERMINATED
 */
public class ThreadStateNRBRT {
    //锁
    private static final Object lock=new Object();

    public static void main(String[] args) {
        //辅助线程，制造synchronized状态。
        Thread assistantThread = new Thread(new SynTask());
        assistantThread.start();
        try {
            //保证assistantThread先执行。
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Thread showThread = new Thread(new Task());
        print(showThread.getName(), showThread.getState());
        showThread.start();
        print(showThread.getName(),showThread.getState());
        //因为无法判断显示线程何时执行，所以循环直到显示线程执行。
        while (true){
            if(showThread.getState()==Thread.State.BLOCKED){
                print(showThread.getName(), Thread.State.BLOCKED);
                break;
            }
        }
        //等待两个线程执行完毕。
        try {
            assistantThread.join();
            showThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //线程执行完毕打印状态。
        print(showThread.getName(), showThread.getState());
    }

    private static class SynTask implements Runnable {
        @Override
        public void run() {
            //锁定一定时间
            synchronized (lock){
                try {
                    Thread.sleep(100);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private static class Task implements Runnable {
        @Override
        public void run() {
            synchronized (lock){
                print(Thread.currentThread().getName(),Thread.currentThread().getState());
            }
        }
    }
}

执行一下你有可能看到正确结果：

Thread-1:NEW
Thread-1:RUNNABLE
Thread-1:BLOCKED
Thread-1:RUNNABLE
Thread-1:TERMINATED

为什么是有可能呢？我们调整一下代码，例如将加锁的时间调小一点：

private static class SynTask implements Runnable {
        @Override
        public void run() {
            //锁定一定时间
            synchronized (lock){
                try {
                    Thread.sleep(10);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
}

注意此处Thread.sleep(10),我们只锁住十毫秒。

再运行一下，控制台可能打印出这样的结果且程序不会结束：

Thread-1:NEW
Thread-1:RUNNABLE
Thread-1:RUNNABLE

造成以上结果的原因是我么无法保证两个线程的执行顺序，也无法证主线程一定能打印出显示线程阻塞的状态。

         while (true){
            if(showThread.getState()==Thread.State.BLOCKED){
                print(showThread.getName(), Thread.State.BLOCKED);
                break;
            }
        }

所以执行在这段代码死循环了。

调整一下代码，保证不会因为参数调整改变线程之间的执行顺序和打印结果。

/**
 * NEW->RUNNABLE->BLOCKED->RUNNABLE->TERMINATED
 */
public class ThreadStateNRBRT_New {
    //锁
    private static final Object lock=new Object();
    //锁定标志
    private volatile static boolean lockFlag=true;
    //执行顺序
    private volatile static int order=0;

    public static void main(String[] args) {
        //展示线程
        Thread showThread = new Thread(new Task());
        print(showThread.getName(), showThread.getState());
        showThread.start();
        print(showThread.getName(), showThread.getState());
        //辅助线程，制造synchronized状态。
        Thread assistantThread = new Thread(new SynTask());
        assistantThread.start();


        //循环读取展示线程状态，直到读到展示线程状态为BLOCKED，才让辅助线程退出同步。
        while (true){
            if(showThread.getState()==Thread.State.BLOCKED){
                print(showThread.getName(), Thread.State.BLOCKED);
                lockFlag=false;
                break;
            }
        }

        try {
            assistantThread.join();
            showThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //线程执行完毕打印状态。
        print(showThread.getName(), showThread.getState());
    }

    private static class SynTask implements Runnable {
        @Override
        public void run() {
            while (true) {
                //保证先进入同步范围。
                if (order == 0) {
                    synchronized (lock) {
                        //启动另一个同步
                        order=1;
                        //等待主线程读取到线程阻塞状态，退出同步。
                        while (lockFlag) {
                            try {
                                Thread.sleep(10);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }
                    break;
                }
            }
        }
    }

    private static class Task implements Runnable {
        @Override
        public void run() {
            while (true){
                //保证后进入同步范围。
                if (order==1){
                    synchronized (lock){
                        print(Thread.currentThread().getName(),Thread.currentThread().getState());
                    }
                    break;
                }
            }
        }
    }
}

我们用order保证线程进入同步区的顺序，用lockFlag保证只有在打印出显示线程的被阻塞状态后辅助线程才退出同步区。这样无论如何执行我们都会得到同样的结果。

Thread-0:NEW
Thread-0:RUNNABLE
Thread-0:BLOCKED
Thread-0:RUNNABLE
Thread-0:TERMINATED

三、新建--->可运行--->等待--->可运行--->被终止

这里我们展示两种三种方法造成线程的等待状态

Object.wait()
java.util.concurrent.locks.Locke.lock()
java.util.concurrent.locks.Condition.await()

其他方法如Thread.join()等大家可以参考示例代码自己实现。

1. Object.wait()

/**
 * NEW->RUNNABLE->WAITING->RUNNABLE->TERMINATED
 */
public class ThreadStateNRWRT {
    //锁
    private static final Object lock=new Object();

    public static void main(String[] args) {
        //展示线程
        Thread showThread = new Thread(new WaitTask());
        print(showThread.getName(), showThread.getState());
        showThread.start();
        print(showThread.getName(),showThread.getState());
        //循环读取展示线程状态，直到读到展示线程状态为WAITING，才让辅助线程唤醒等待线程。
        while (true){
            if(showThread.getState()==Thread.State.WAITING){
                print(showThread.getName(), Thread.State.WAITING);
                break;
            }
        }
        synchronized (lock){
            lock.notify();
        }


        try {
            showThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //线程执行完毕打印状态。
        print(showThread.getName(), showThread.getState());
    }


    private static class WaitTask implements Runnable {
        @Override
        public void run() {
            //等待
            synchronized (lock){
                try {
                    lock.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            print(Thread.currentThread().getName(),Thread.currentThread().getState());
        }
    }
}

2. java.util.concurrent.locks.Locke.lock()

/**
 * NEW->RUNNABLE->WAITING->RUNNABLE->TERMINATED
 */
public class ThreadStateNRWRTLock {
    //锁
    private  static Lock lock=new ReentrantLock();
    //锁定标志
    private volatile static boolean lockFlag=true;
    //执行顺序
    private volatile static int order=0;

    public static void main(String[] args) {
        //展示线程
        Thread showThread = new Thread(new Task());
        print(showThread.getName(), showThread.getState());
        showThread.start();
        print(showThread.getName(), showThread.getState());
        //辅助线程，制造synchronized状态。
        Thread assistantThread = new Thread(new SynTask());
        assistantThread.start();
        //循环读取展示线程状态，直到读到展示线程状态为BLOCKED，才让辅助线程退出同步。
        while (true){
            if(showThread.getState()==Thread.State.WAITING){
                print(showThread.getName(), Thread.State.WAITING);
                lockFlag=false;
                break;
            }
        }
        try {
            assistantThread.join();
            showThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //线程执行完毕打印状态。
        print(showThread.getName(), showThread.getState());
    }

    private static class SynTask implements Runnable {
        @Override
        public void run() {
            while (true) {
                //保证先进入同步范围。
                if (order == 0) {
                    //加锁
                    lock.lock();
                    try {
                        order=1;
                        while (lockFlag) {
                            try {
                                Thread.sleep(10);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    }finally {
                        lock.unlock();
                    }
                    break;
                }
            }
        }
    }

    private static class Task implements Runnable {
        @Override
        public void run() {
            while (true){
                //保证后进入同步范围。
                if (order==1){
                    lock.lock();
                    try{
                        print(Thread.currentThread().getName(),Thread.currentThread().getState());
                    }finally {
                        lock.unlock();
                    }
                    break;
                }
            }
        }
    }
}

3. java.util.concurrent.locks.Condition.await()

/**
 * NEW->RUNNABLE->WAITING->RUNNABLE->TERMINATED
 */
public class ThreadStateNRWRTCondition {
    //锁
    private static Lock lock=new ReentrantLock();
    private static Condition condition=lock.newCondition();

    public static void main(String[] args) {
        //展示线程
        Thread showThread = new Thread(new WaitTask());
        print(showThread.getName(), showThread.getState());
        showThread.start();
        print(showThread.getName(),showThread.getState());
        //循环读取展示线程状态，直到读到展示线程状态为WAITING，才让辅助线程唤醒等待线程。
        while (true){
            if(showThread.getState()==Thread.State.WAITING){
                print(showThread.getName(), Thread.State.WAITING);
                break;
            }
        }

        lock.lock();
        try{
            condition.signal();
        }finally {
            lock.unlock();
        }


        try {
            showThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //线程执行完毕打印状态。
        print(showThread.getName(), showThread.getState());
    }


    private static class WaitTask implements Runnable {
        @Override
        public void run() {
            //等待
            lock.lock();
            try{
                try {
                    condition.await();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }finally {
                lock.unlock();
            }
            print(Thread.currentThread().getName(),Thread.currentThread().getState());
        }
    }
}

4. 运行结果

三段代码的运行结果都是：

Thread-0:NEW
Thread-0:RUNNABLE
Thread-0:WAITING
Thread-0:RUNNABLE
Thread-0:TERMINATED

四、新建--->可运行--->计时等待--->可运行--->被终止

我们展示两个方法造成计时等待状态

Object.wait(long timeout)
java.util.concurrent.locks.Condition.await(long time, TimeUnit unit)

其他方法如Thread.sleep(long millis),Thread.join(long millis)等大家可以自己实现。
感觉凡是有超时方法的方法都能让线程状态进入计时等待，但是这个没有经过验证，所以只是一个猜想。

1. Object.wait(long timeout)

/**
 * NEW->RUNNABLE->TIMED_WAITING->RUNNABLE->TERMINATED
 */
public class ThreadStateNRTWRT {
    //锁
    private static final Object lock=new Object();

    public static void main(String[] args) {
        //展示线程
        Thread showThread = new Thread(new WaitTask());
        print(showThread.getName(), showThread.getState());
        showThread.start();
        print(showThread.getName(),showThread.getState());
        //循环读取展示线程状态，直到读到展示线程状态为TIMED_WAITING。
        while (true){
            if(showThread.getState()==Thread.State.TIMED_WAITING){
                print(showThread.getName(), Thread.State.TIMED_WAITING);
                break;
            }
        }

        try {
            showThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //线程执行完毕打印状态。
        print(showThread.getName(), showThread.getState());
    }


    private static class WaitTask implements Runnable {
        @Override
        public void run() {
            //等待
            synchronized (lock){
                try {
                    lock.wait(1);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            print(Thread.currentThread().getName(),Thread.currentThread().getState());
        }
    }
}

2. java.util.concurrent.locks.Condition.await(long time, TimeUnit unit)

/**
 * NEW->RUNNABLE->TIMED_WAITING->RUNNABLE->TERMINATED
 */
public class ThreadStateNRTWRTCondition {
    //锁
    private static Lock lock=new ReentrantLock();
    private static Condition condition=lock.newCondition();

    public static void main(String[] args) {
        //展示线程
        Thread showThread = new Thread(new WaitTask());
        print(showThread.getName(), showThread.getState());
        showThread.start();
        print(showThread.getName(),showThread.getState());
        //循环读取展示线程状态，直到读到展示线程状态为TIMED_WAITING。
        while (true){
            if(Thread.State.TIMED_WAITING==showThread.getState()){
                print(showThread.getName(), Thread.State.TIMED_WAITING);
                break;
            }
        }
        try {
            showThread.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //线程执行完毕打印状态。
        print(showThread.getName(), showThread.getState());
    }


    private static class WaitTask implements Runnable {
        @Override
        public void run() {
            //等待
            lock.lock();
           try{
                try {
                    condition.await(1,TimeUnit.MILLISECONDS);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }finally {
               lock.unlock();
           }
            print(Thread.currentThread().getName(),Thread.currentThread().getState());
        }
    }
}

3. 运行结果

两段程序的运行结果相同：

Thread-0:NEW
Thread-0:RUNNABLE
Thread-0:TIMED_WAITING
Thread-0:RUNNABLE
Thread-0:TERMINATED

结语

至此，我们已经介绍了线程状态转换的所有情况，了解线程状态转换对分析多线程代码运行很帮助。希望本篇文章对大家今后工作有所助力。

内容总结

以上是互联网集市为您收集整理的一文读懂Java线程状态转换全部内容，希望文章能够帮你解决一文读懂Java线程状态转换所遇到的程序开发问题。如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容，请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/628686.html

来源：【匿名】

【上一篇】0616 Java核心技术卷1 【下一篇】JAVA/JSP学习系列之五

更多 ►

【一文读懂Java线程状态转换】教程文章相关的互联网学习教程文章

1. 线程状态类型 1. 新建状态（New）：新创建了一个线程对象。2. 就绪状态（Runnable）：线程对象创建后，其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中，变得可运行，等待获取CPU的使用权。3. 运行状态（Running）：就绪状态的线程获取了CPU，执行程序代码。4. 阻塞状态（Blocked）：阻塞状态是线程因为某种原因放弃CPU使用权，暂时停止运行。直到线程进入就绪状态，才有机会转到运行状态。阻塞的情况分三...

Java的线程状态【代码】

Java的线程状态线程方法方法说明setPriority(int newPriority)更改线程的优先级static void sleep(long millis)在指定的毫秒数内让当前正在执行的线程休眠void join()等待该线程终止static void yield()暂停当前正在执行的线程对象，并执行其他线程void interrupt()中断线程，别用这个方式boolean isAlive()测试线程是否处于活动状态停止线程不推荐使用JDK提供的stop()、destroy()方法。【已废弃】推荐线程自己停下来建议使用一个标...

java多线程：线程状态【代码】【图】

线程状态（五大状态）void setPriority(int newPriority) 更改线程的优先级。static void sleep(long millis) 在指定的毫秒数内让当前正在执行的线程休眠（暂停执行），此操作受到系统计时器和调度程序精度和准确性的影响。void join() 等待该线程终止。static void yield() 暂停当前正在执行的线程对象，并执行其他线程。void interrupt() 中断线程。 (别用这个方式)boolean isAlive() 测试线程是否处于活动状态。线程停止不推荐使...

【JAVA并发第二篇】Java线程的创建与运行，线程状态与常用方法【代码】【图】

1、线程的创建与运行（1）、继承或直接使用Thread类继承Thread类创建线程： /*** 主类*/ public class ThreadTest {public static void main(String[] args) {//创建线程对象My_Thread my_thread = new My_Thread();//启动线程my_thread.start();} } /**继承Thread */ class My_Thread extends Thread{ @Override public void run(){ //线程的任务 System.out.println("My_Thread Running"); } }直接使用Thread类创建线程： cla...

Java 线程状态之 TIMED_WAITING【代码】【图】

在上一篇章中我们谈论了 WAITING 状态，在这一篇章里，我们来看剩余的最后的一个状态：TIMED_WAITING（限时等待）。定义一个正在限时等待另一个线程执行一个动作的线程处于这一状态。A thread that is waiting for another thread to perform an action for up to a specified waiting time is in this state.更详细的定义还是看 javadoc（jdk8）：带指定的等待时间的等待线程所处的状态。一个线程处于这一状态是因为用一个指定的...

【原创】Java并发编程系列10 | 线程状态【代码】【图】

【原创】Java并发编程系列10 | 线程状态收录于话题 #进阶架构师 | 并发编程专题 12个点击上方“java进阶架构师”，选择右上角“置顶公众号”20大进阶架构专题每日送达Java并发编程脑图本文为何适原创并发编程系列第 10 篇，前面几篇没看过的，可以在文末找到前几篇的跳转链接。前面几篇理论知识介绍了一大堆，实际编程中线程应该怎么用呢？接下来就要开始介绍实际编程中如何操作线程，本文内容如下：如何创建并启动线程？创建并...

一文读懂Java线程状态转换【图】

主要以代码示例说明线程状态如何转换。基础知识 1. 线程状态线程可以有6种状态：New（新建） Runnable（可运行） Blocked（被阻塞） Waiting（等待） Timed waiting（计时等待） Terminated（被终止）New：new Thread()后线程的状态就是新建。 Runnable：线程一旦调用start()方法，无论是否运行，状态都为Runable，注意Runable状态指示表示线程可以运行，不表示线程当下一定在运行，线程是否运行由虚拟机所在操作系统调度决定。 ...

深入理解Java线程状态转移【代码】【图】

目录前言状态转移图1.0 新建态到就绪态1.1 就绪态到运行态1.2 运行态到就绪态1.2.1 时间片用完1.2.2 t1.yield() 、Thread.yield();1.3 运行态到阻塞态1.3.1 Thread.sleep()1.3.2 t2.join()1.3.3 t1等待用户输入，等待键盘响应1.4 阻塞态到就绪态1.5 运行态到等待队列1.6 运行态到锁池队列1.7 等待队列到锁池队列1.8 锁池队列到就绪态1.9 运行态到死亡态前言看到网上关于线程状态转移的博客，好多都没说明白。查了很多资料，汇总一...

Java线程状态【代码】

看源码得知：public enum State {/*** Thread state for a thread which has not yet started.*/NEW,/*** Thread state for a runnable thread. A thread in the runnable* state is executing in the Java virtual machine but it may* be waiting for other resources from the operating system* such as processor.*/RUNNABLE,/*** Thread state for a thread blocked waiting for a monitor lock.* A thread in the blocked ...

java 线程状态（等待和唤醒）【代码】

package com.jack.test2;public class main {static Object obj = new Object();static int total = 100;static int tikets = total;static int pre = total / 2; //前面pre张票，必须thead2才能卖public static void main(String[] args) {Thread r1 = new Thread() {@Overridepublic void run() {while (true) {synchronized (obj) {if (tikets >= total - pre) {try {System.out.println(Thread.currentThread().getName() + "在...

Java 线程状态

线程状态：new 新生 start 准备就绪运行状态阻塞状态（sleep， wait，同步锁）死亡状态线程停止：1.标志位停止；2.自动停止，利用次数线程休眠：模拟延时。每个对象都有一把锁，sleep不会释放锁。Thread.sleep(); 线程礼让：Thread.yield() 线程合并：Thread.join() 插队观测线程状态：Thread.state() new runable waiting dead 线程优先级：priority 1-10 执行顺序并不一定按优先级跑守护线程：Thre...

Java线程状态介绍【代码】

原创：转载需注明原创地址 https://www.cnblogs.com/fanerwei222/p/11867086.html Java 线程状态介绍: Java官方文档中对Java线程的几种状态做了说明, 说明如下;public static enum Thread.State extends Enum<Thread.State>A thread state. A thread can be in one of the following states:NEWA thread that has not yet started is in this state.RUNNABLEA thread executing in the Java virtual machine is in this state.BLO...

java-线程池中的线程状态【代码】

我想监视ThreadLocals中的内存泄漏.要获取所有线程本地对象,我使用此处的代码http://blog.igorminar.com/2009/03/identifying-threadlocal-memory-leaks-in.html.此代码使用反射来提取当前线程上的所有线程本地. 我想要一个监视所有线程的后台线程. 在所有线程上运行(在ThreadGroup上进行递归调用)很简单.但是,我需要知道哪些线程当前未运行并且仍在使用线程本地对象. 例如：线程A使用LocalThread A1.线程完成并返回到容器的线程池...

java-多线程状态相关的问题【代码】

给出了以下代码片段：public class ThreadTest{private static class Thread01 extends Thread{private Thread02 _th2; public int foo = 0;public void setThrd02(Thread02 thrd2){_th2 = thrd2;}public void run(){try{for(int i=0;i<10;i++) foo += i;synchronized(this){this.notify();};synchronized(_th2){_th2.wait();};System.out.print(" Foo: " + _th2.foo);}catch(InterruptedException ie){ ie.printStackTrace();} ...

Java面经合集：CMS+红黑树+线程状态+事务隔离+中间件【图】

马上进入求职招聘高峰，总结了一份BAT(阿里、百度等)资深Java相关的面试题合集给到大家，希望在接下来的面试求职中会对大家有所帮助。文末有相关的2019最新BAT资深java面试题答案~用于参考 JVMJVM内存模型结构JVM的垃圾回收算法？JVM有哪些GC，各自的区别?方法区和直接内存什么时候会oom？JVM收集器G1的内存模型和CMS的内存模型有什么不同？jvm调优用过吗？如何查看java内存使用情况（jconsole、命令jmap、jstack等等）集合Array...

首页 / JAVA / 一文读懂Java线程状态转换

一文读懂Java线程状态转换

内容导读

内容图文

基础知识

1. 线程状态

2. 线程状态转换

用代码说话

一、 新建--->可运行--->被终止

二、 新建--->可运行--->被阻塞--->可运行--->被终止

三、 新建--->可运行--->等待--->可运行--->被终止

1. Object.wait()

2. java.util.concurrent.locks.Locke.lock()

3. java.util.concurrent.locks.Condition.await()

4. 运行结果

四、新建--->可运行--->计时等待--->可运行--->被终止

1. Object.wait(long timeout)

2. java.util.concurrent.locks.Condition.await(long time, TimeUnit unit)

3. 运行结果

结语

内容总结

内容备注

内容手机端

【一文读懂Java线程状态转换】教程文章相关的互联网学习教程文章

JAVA - 相关标签

状态 - 相关标签

JAVA - 技术教程分类

JAVA - 最新教程

JAVA - 最热教程

一、新建--->可运行--->被终止

二、新建--->可运行--->被阻塞--->可运行--->被终止

三、新建--->可运行--->等待--->可运行--->被终止