精华内容
下载资源
问答
  • Java线程状态转化

    2018-09-30 17:26:49
    先来一张线程状态转化图,然后我再慢慢解释: 在Java中线程的状态一共被分成6种: 初始态:NEW 创建一个Thread对象,但还未调用start()启动线程时,线程处于初始态。 运行态:RUNNABLE 在Java中,运行态包括...

    先来一张线程状态转化图,然后我再慢慢解释:

    在Java中线程的状态一共被分成6种:

    初始态:NEW

    创建一个Thread对象,但还未调用start()启动线程时,线程处于初始态。

    运行态:RUNNABLE

    在Java中,运行态包括就绪态 和 运行态。

    • 就绪态
      • 该状态下的线程已经获得执行所需的所有资源,只要CPU分配执行权就能运行。
      • 所有就绪态的线程存放在就绪队列中。
    • 运行态
      • 获得CPU执行权,正在执行的线程。
      • 由于一个CPU同一时刻只能执行一条线程,因此每个CPU每个时刻只有一条运行态的线程。

    阻塞态

    • 当一条正在执行的线程请求某一资源失败时,就会进入阻塞态。
    • 而在Java中,阻塞态专指请求锁失败时进入的状态。
    • 由一个阻塞队列存放所有阻塞态的线程。
    • 处于阻塞态的线程会不断请求资源,一旦请求成功,就会进入就绪队列,等待执行。

    PS:锁、IO、Socket等都资源。

    等待态

    • 当前线程中调用wait、join、park函数时,当前线程就会进入等待态。
    • 也有一个等待队列存放所有等待态的线程。
    • 线程处于等待态表示它需要等待其他线程的唤醒才能继续运行。
    • 进入等待态的线程会释放CPU执行权,并释放资源(如:锁)

    超时等待态

    • 当运行中的线程调用sleep(time)、wait、join、parkNanos、parkUntil时,就会进入该状态;
    • 它和等待态一样,并不是因为请求不到资源,而是主动进入,并且进入后能够自动唤醒,不需要其他线程唤醒;
    • 进入该状态后释放CPU执行权 和 占有的资源。
    • 与等待态的区别:到了超时时间后自动进入阻塞队列,开始竞争锁。

    终止态

    线程执行结束后的状态。

     

    注意:

    • wait()方法会释放CPU执行权 和 占有的锁。
    • sleep(long)方法仅释放CPU使用权,锁仍然占用;线程被放入超时等待队列,与yield相比,它会使线程较长时间得不到运行。
    • yield()方法仅释放CPU执行权,锁仍然占用,线程会被放入就绪队列,会在短时间内再次执行。
    • wait和notify必须配套使用,即必须使用同一把锁调用;
    • wait和notify必须放在一个同步块中
    • 调用wait和notify的对象必须是他们所处同步块的锁对象。(不然报错IllegalMonitorStateException)

    转自:https://www.zhihu.com/question/27654579/answer/252912242 

    有资源有执行权:运行态
    有资源无执行权:就绪态
    无资源无执行权:阻塞态(会一直请求资源)
    主动释放资源和执行权,不设置超时时间,需要被唤醒:等待态
    主动释放资源和执行权,设置超时时间,能自动唤醒:超时等待态

    --------------------------------------------------------------------------------------

    从上面的例子中,我们看到了线程状态有BLOCKED,WAITING,TIMED_WAITING。 实际上线程状态有如下几种

    线程状态

    1. 新建状态(New):新创建了一个线程对象。
    2. 就绪状态(Runnable):线程对象创建后,其他线程调用了该对象的start()方法。该状态的线程位于可运行线程池中,变得可运行,等待获取CPU的使用权。
    3. 运行状态(Running):就绪状态的线程获取了CPU,执行程序代码。
    4. 阻塞状态(Blocked):阻塞状态是线程因为某种原因放弃CPU使用权,暂时停止运行。直到线程进入就绪状态,才有机会转到运行状态。阻塞的情况分三种:
    (一)、WAITING (on object monitor) 等待阻塞:运行的线程执行wait()方法,JVM会把该线程放入等待池中。
    (二)、BLOCKED (on object monitor) 同步阻塞:运行的线程在获取对象的同步锁时,若该同步锁被别的线程占用,则JVM会把该线程放入锁池中。区分同步阻塞和等待阻塞也可以看锁的特征,例如同步阻塞锁的特征是waiting for monitor, 等待阻塞锁的特征是object.wait()
    (三)、TIMED_WAITING(sleeping) 其他阻塞:运行的线程执行sleep()或join()方法,或者发出了I/O请求时,JVM会把该线程置为阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。
    5. 死亡状态(Dead):线程执行完了或者因异常退出了run()方法,该线程结束生命周期。

    原文链接:https://blog.csdn.net/T1DMzks/article/details/82719998

     

    展开全文
  • Java线程状态转换

    2018-06-29 15:26:00
    2019独角兽企业重金招聘Python工程师标准>>> ...

    转载于:https://my.oschina.net/hengbao666/blog/1837736

    展开全文
  • Java线程状态转换详解

    2019-06-05 11:21:26
    线程状态类型 新建状态(New) 用new语句创建的线程对象处于新建状态,此时它和其他Java对象一样,仅仅在堆区被分配了内存。 就绪状态(Runnable) 当一个线程对象创建后,其他线程调用它的start()方法,该线程...

    线程的状态转换图

    线程状态类型

    新建状态(New)

    用new语句创建的线程对象处于新建状态,此时它和其他Java对象一样,仅仅在堆区被分配了内存。

    就绪状态(Runnable)

    当一个线程对象创建后,其他线程调用它的start()方法,该线程就进入就绪状态,Java虚拟机会为它创建方法调用栈和程序计数器。处于这个状态的线程位于可运行池中,等待获得CPU的使用权。

    运行状态(Running)

    处于这个状态的线程占用CPU,执行程序代码。在并发编程环境中,如果计算机只有一个CPU,那么任何时刻只会有一个线程处于这个状态。如果计算机有多个CPU,那么同一时刻可以让几个线程占用不同的CPU,使它们都处于运行状态。只有处于就绪状态的线程才有机会转到运行状态。

    阻塞状态(Blocked)

    阻塞状态是指线程因为某些原因放弃CPU,暂时停止线程。当线程处于阻塞状态时,Java虚拟机不会给线程分配CPU,直到线程重新进入就绪状态,它才有机会转到运行状态。

    阻塞状态可以分为以下三种:

    等待阻塞:位于对象等待池中的阻塞状态(Blocked in object's wait pool),当线程处于运行状态时,如果执行了某个对象的wait()方法,Java虚拟机就会把线程放到这个对象的等待池中。

    同步阻塞:位于对象锁池中的等待状态(Blocked in object's lock pool),当线程处于运行状态,试图获得某个对象的同步锁时,如果该对象的同步锁已经被其他线程占用,Java就会把这个线程放到这个对象的锁池中。

    其他阻塞:当前线程执行了sleep()方法,或者调用了其他线程的join()方法,或者发出了I/O请求,就会进入这个状态。

    死亡状态(Dead)

    当线程退出run()方法时,就进入死亡状态,该线程结束生命周期。线程有可能是正常执行完run()方法而退出,也有可能是遇到异常而退出

    在《JAVA并发编程的艺术》一书中线程的状态如下:

    注意: 同步阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态,阻塞在java.concurrent包中Lock接口的线程状态却是等待阻塞状态,因为java.concurrent包中Lock接口对于阻塞的实现均使用了LockSupport类中的相关方法。

    线程调度的方法

    Thread.sleep()方法

    public static native void sleep(long millis)是Thread的静态方法,它是让当前线程按照指定的时间休眠,其休眠时间的精度取决于处理器的计时器和调度器。需要注意的是如果当前线程获得了锁,sleep方法并不会失去锁。sleep方法经常拿来与Object.wait()方法进行比价,这也是面试经常被问的地方。

    sleep() VS wait()

    两者主要的区别:

    1. sleep()方法是Thread的静态方法,而wait是Object实例方法
    2. wait()方法必须要在同步方法或者同步块中调用,也就是必须已经获得对象锁。而sleep()方法没有这个限制可以在任何地方种使用。另外,wait()方法会释放占有的对象锁,使得该线程进入等待池中,等待下一次获取资源。而sleep()方法只是会让出CPU并不会释放掉对象锁;
    3. sleep()方法在休眠时间达到后如果再次获得CPU时间片就会继续执行,而wait()方法必须等待Object.notift/Object.notifyAll通知后,才会离开等待池,并且再次获得CPU时间片才会继续执行。

     Thread.yield()方法

    public static native void yield()也是Thread的静态方法。如果此时具有相同优先级的其他线程处于就绪状态,那么yield()方法将当前运行的线程放到运行池中,并从线程池中任意挑选一个线程运行。如果没有相同优先级的可运行线程,则yield()方法什么也不做。需要注意的是,让出的CPU并不是代表当前线程不再运行了,如果在下一次竞争中,又获得了CPU时间片当前线程依然会继续运行。

    join()方法

    当前线程可以调用另一个线程的join()方法,可以看做是线程间协作的一种方式,当前运行的线程将转到阻塞状态,直至另一个线程结束,他才会恢复运行 

    参考文献

    《Java面向对象编程》

    《JAVA并发编程的艺术》

    展开全文
  • 详细介绍了Java线程的6种状态,以及状态之间的转换。

    详细介绍了Java线程的6中状态,以及状态之间的转换。


    本文基于JDK1.8。

    1 线程状态(生命周期)

    1.1 源码中的状态

    关于Java线程的状态,网上说法很多,有五种、六种甚至七种,本文采用Java官方的线程状态分类。

    实际上,官方一共给出了六种线程状态,我们来看看源码便可知:

        public class Thread implements Runnable {
            //线程的状态以枚举的方式定义在Thread类的内部
            /**
             * 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.
             *     </li>
             * <li>{@link #RUNNABLE}<br>
             *     A thread executing in the Java virtual machine is in this state.
             *     </li>
             * <li>{@link #BLOCKED}<br>
             *     A thread that is blocked waiting for a monitor lock
             *     is in this state.
             *     </li>
             * <li>{@link #WAITING}<br>
             *     A thread that is waiting indefinitely for another thread to
             *     perform a particular action is in this state.
             *     </li>
             * <li>{@link #TIMED_WAITING}<br>
             *     A thread that is waiting for another thread to perform an action
             *     for up to a specified waiting time is in this state.
             *     </li>
             * <li>{@link #TERMINATED}<br>
             *     A thread that has exited is in this state.
             *     </li>
             * </ul>
             *
             * <p>
             * A thread can be in only one state at a given point in time.
             * These states are virtual machine states which do not reflect
             * any operating system thread states.
             *
             * @since   1.5
             * @see #getState
             */
            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 state is waiting for a monitor lock
                 * to enter a synchronized block/method or
                 * reenter a synchronized block/method after calling
                 * {@link Object#wait() Object.wait}.
                 */
                BLOCKED,
    
                /**
                 * Thread state for a waiting thread.
                 * A thread is in the waiting state due to calling one of the
                 * following methods:
                 * <ul>
                 *   <li>{@link Object#wait() Object.wait} with no timeout</li>
                 *   <li>{@link #join() Thread.join} with no timeout</li>
                 *   <li>{@link LockSupport#park() LockSupport.park}</li>
                 * </ul>
                 *
                 * <p>A thread in the waiting state is waiting for another thread to
                 * perform a particular action.
                 * <p>
                 * For example, a thread that has called <tt>Object.wait()</tt>
                 * on an object is waiting for another thread to call
                 * <tt>Object.notify()</tt> or <tt>Object.notifyAll()</tt> on
                 * that object. A thread that has called <tt>Thread.join()</tt>
                 * is waiting for a specified thread to terminate.
                 */
                WAITING,
    
                /**
                 * Thread state for a waiting thread with a specified waiting time.
                 * A thread is in the timed waiting state due to calling one of
                 * the following methods with a specified positive waiting time:
                 * <ul>
                 *   <li>{@link #sleep Thread.sleep}</li>
                 *   <li>{@link Object#wait(long) Object.wait} with timeout</li>
                 *   <li>{@link #join(long) Thread.join} with timeout</li>
                 *   <li>{@link LockSupport#parkNanos LockSupport.parkNanos}</li>
                 *   <li>{@link LockSupport#parkUntil LockSupport.parkUntil}</li>
                 * </ul>
                 */
                TIMED_WAITING,
    
                /**
                 * Thread state for a terminated thread.
                 * The thread has completed execution.
                 */
                TERMINATED;
            }
        }
    

    从源码可以看出,Java语言定义了6种线程状态,作为内部枚举保存在Thread类中。这里我建议大家采用这六种状态,当然也可以按照自己的理解来。下面来解释一下每一种状态。

    1.2 状态解释

    在任意一个时间点,一个线程只能有且只有其中的一种状态,这6种状态分别如下:

    1. 新建(NEW):创建后尚未启动的线程处于这种状态。
    2. 运行(RUNNABLE):调用start()方法,RUNNABLE包括了操作系统线程状态中的Running和Ready,也就是处于此状态的线程有可能正在执行,也有可能正在等待着CPU为它分配执行时间(该线程已经获取了除CPU资源外的其他资源,等待获取CPU 资源后才会真正处于运行状态)。

    官方为什么不将这两种状态分开呢?有种可能是:线程在这Running和Ready两种状态之间的时长太短了,现代cpu采用轮询式时间片调度,大部分线程Running和Ready的时间都非常短暂,因此考虑将这两种状态合并为RUNNABLE状态。

    1. 无限期等待(WAITING):处于这种状态的线程不会被分配CPU执行时间,它们要等待被其他线程显式地唤醒。以下方法会让线程陷入无限期的等待状态:
    1. 没有设置Timeout参数的Object.wait()方法。
    2. 没有设置Timeout参数的Thread.join()方法。
    3. LockSupport.park()方法。
    1. 限期等待(TIMED_WAITING):处于这种状态的线程也不会被分配CPU执行时间,不过无须等待被其他线程显式地唤醒,在一定时间之后它们会由系统自动唤醒。以下方法会让线程进入限期等待状态:
    1. Thread.sleep(long millis)方法。
    2. 设置了Timeout参数的Object.wait()方法。
    3. 设置了Timeout参数的Thread.join()方法。
    4. LockSupport.parkNanos()方法。
    5. LockSupport.parkUntil()方法。
    1. 阻塞(BLOCKED):线程被阻塞了,“阻塞状态”与“等待状态”的区别是:“阻塞状态”在等待着获取到一个排他锁,这个事件将在另外一个线程获得锁的时候可能发生,比如synchronized之外;而“等待状态”则是在获得锁之后,主动释放锁,进入等待一段时间,或者等待唤醒动作的发生。

    2. 结束(TERMINATED):已终止线程的线程状态,线程已经结束执行。

    补充:
    Java将操作系统中的运行和就绪两个状态合并称为运行状态。

    阻塞状态是线程阻塞在进入synchronized关键字修饰的方法或代码块(获取锁)时的状态,但是阻塞在java.concurrent包中Lock接口的线程状态却是等待状态,因为java.concurrent包中Lock接口对于阻塞的实现均使用了LockSupport类中的相关方法。

    线程状态概述

    2 线程状态转换

    上述6种状态在遇到特定事件发生的时候将会互相转换,它们的转换关系如下图:

    线程转换图

    上图状态的转换和方法已经很明朗了,下面重点说说几种状态转换,以及相关方法补充。

    2.1 进入等待/超时等待

    2.1.1 进入等待状态

    1. LockSupport.park()。
    2. 发生Io阻塞。
    3. suspend(),方法已过时。
    4. public final void wait() 释放锁
    5. public final void join() 释放锁

    2.1.1.1 wait方法的介绍

    wait方法属于object类,wait()方法使当前线程暂停执行并释放锁,让其他线程可以进入synchronized数据块,当前线程被放入对象等待队列中。Wait()方法必须被包含在对应的synchronized语句中,无论是wait()方法还是notify()方法都需要获取目标对象的一个监视器。

    当调用notify()方法后,将从对象的等待队列中移走一个任意的线程并放到锁标志等待池中,只有锁标志等待池中线程才可能够获取锁标志;如果等待队列中没有线程,则notify()不起作用。notifyAll()则从对象等待池中移走所有等待那个对象的线程并放到锁标志等待池中。

    被唤醒的线程并不会立即执行而是尝试获得锁,执行唤醒方法的线程也并不会立即释放锁。

    2.1.1.2 join方法的介绍

    join方法在内部使用wait()方法进行等待,底层用wait()来实现,可以释放锁。join方法上加了synchronuzed关键字,因此使用wait没有问题。

    join方法的主要作用就是同步,它可以使得线程之间的并行执行变为串行执行,有些类似于同步的运行效果。在A线程中调用了B线程的join()方法时,表示只有当B线程执行完毕时,A线程才能继续执行。如果有多个线程,除了A线程之外的其他线程正常竞争cpu和锁。

    join方法中如果传入参数,则表示这样的意思:如果A线程中调用B线程的join(10),则表示A线程会等待B线程执行10毫秒,10毫秒过后,A、B线程并行执行。需要注意的是,jdk规定,join(0)的意思不是A线程等待B线程0秒,而是A线程等待B线程无限时间,直到B线程执行完毕,即join(0)等价于join()。(其实join()中调用的是join(0))。主线程中调用join,则主线程等待, 其他多个线程之间并不需要互相等待。

    join()与synchronized的区别是:join在内部调用wait()方法进行等待,而synchronized关键字使用的是"对象监视器"原理作为同步。

        /**
         * join方法
         * @throws InterruptedException
         */
        public final void join() throws InterruptedException {
            //内部调用join(long millis)方法,参数为0 ,表示无限等待
            join(0);
        }
    
        /**
         * 等待millis毫秒
         * @param millis
         * @throws InterruptedException
         */
        public final synchronized void join(long millis)
                throws InterruptedException {
            long base = System.currentTimeMillis();
            long now = 0;
    
            if (millis < 0) {
                throw new IllegalArgumentException("timeout value is negative");
            }
            //millis等于0 表示无限期等待
            if (millis == 0) {
                while (isAlive()) {
                    //调用wait方法
                    wait(0);
                }
            } 
            //否则,限时等待
            else {
                while (isAlive()) {
                    long delay = millis - now;
                    if (delay <= 0) {
                        break;
                    }
                    //调用wait方法
                    wait(delay);
                    now = System.currentTimeMillis() - base;
                }
            }
        }
    

    2.1.2 进入超时等待

    1. public final void join(long millis) --超时等待 释放锁
    2. LockSupport.parkNanos
    3. LockSupport.parkUntil
    4. wait(long timeout); --超时等待 释放锁
    5. public static void sleep(long millis); —超时等待 不释放锁

    2.1.2.1 sleep方法的介绍

    sleep方法使当前线程(即调用该方法的线程)暂停执行一段时间,让其他线程有机会继续执行,但它并不释放对象锁。也就是说如果有synchronized同步快,其他线程仍然不能访问共享数据。注意该方法要捕捉异常。sleep会让其他所有线程都有同等的cpu争夺权力

    睡眠时被中断,则会在sleep()处抛出InterruptedException 异常。

    在调用Thread.sleep(long millis)时为millis 参数传递了一个负数, 则会抛出IllegalArgumentException 异常.

    2.1.2.2 LockSupport类简介

    LockSupport是一个线程阻塞工具类,所有的方法都是静态方法,可以让线程在任意位置阻塞,当然阻塞之后肯定得有唤醒的方法。

    常用方法:

    方法名称描述
    void park()阻塞当前线程,如果调用unpark(Thread)方法或被中断,才能从park()返回。
    void parkNanos(long nanos)阻塞当前线程,超时返回,阻塞时间最长不超过nanos纳秒。
    void parkUntil(long deadline)阻塞当前线程,直到deadline时间点
    void unpark(Thread)唤醒处于阻塞状态的线程

    park不需要获取某个对象的锁。因为中断的时候park不会抛出InterruptedException异常,所以需要在park之后自行判断中断状态,然后做额外的处理。

    2.1.2.3 过期的suspend和resume方法

    suspend方法被不推荐使用。不推荐使用suspend()去挂起线程的原因,是因为suspend()在导致线程暂停的同时,并不会去释放任何锁资源。其他线程都无法访问被它占用的锁。直到对应的线程执行resume()方法后,被挂起的线程才能继续,从而其它被阻塞在这个锁的线程才可以继续执行。如果resume()操作出现在suspend()之前执行,那么线程将一直处于挂起状态,同时一直占用锁,这就容易产生死锁。

    而且,对于被挂起的线程,它的线程状态居然还是RUNNABLE

            //创建子线程,在其内部调用suspend让其"阻塞"
            Thread thread = new Thread(() -> Thread.currentThread().suspend());
            thread.start();
            //主线程睡眠三秒,让子线程充分运行
            Thread.currentThread().sleep(3000);
            //获取子线程状态,发现还是RUNNABLE状态
            Thread.State state = thread.getState();
            System.out.println(state);
    

    2.4 进入RUNNABLE状态

    1. TIMED_WAITING状态结束
    2. WAITING状态被唤醒
    3. BLOCKED状态获得锁
    4. public static void yield();
    5. 线程的cpu时间片使用完毕还未执行完任务,重回就绪态,但此时不会释放锁。

    2.4.1 yield方法的介绍

    yield方法又称为“线程礼让”,使调用线程释放cpu执行权,让自己和其他多个线程重新争夺cpu执行权。

    线程直接回到RUNNABLE状态,而不是让线程处于阻塞态,因此也有可能是当前让步的线程又进入到“运行状态”继续运行

    yield会尽量让同等级和高等级的线程具有更大的争夺权,而sleep会让所有线程都有同等的争夺权力,但它们并不是绝对的。毕竟java线程最终是调用操作系统的资源生成的,充满了不确定性。

    yield方法不会释放持有已获得的锁,只是释放cpu的执行权

    如果有什么不懂或者需要交流,各位可以留言。另外,希望收藏、关注一下,我将不间断更新Java各种教程!

    展开全文
  • JAVA 线程状态转化

    2019-06-07 22:32:47
    文章目录线程状态图说明:线程共包括以下5种状态。1. wait(), notify(), notifyAll()等方法介绍2. 为什么notify(), wait()等函数定义在Object中,而不是Thread中3. yield()介绍4. yield() 与 wait()的比较 线程状态...
  • 一、背景 本文讲得内容比较简单,多线程大家接触很多,但是真正理解到位可能需要一点时间,尤其对新手来说。 本文顺便梳理一下多线程的知识,以两个简单的小...二、Java线程状态 线程共包括以下5种状态。 1.新...
  • Java线程状态

    千次阅读 2014-11-29 19:03:17
    线程跟人类一样拥有自己的生命周期,一条线程从创建到执行完毕的过程即是线程的生命周期,此过程可能在不同时刻处于不同的状态,线程状态正是这小节的主题,线程到底有多少种状态?不同状态之间是如何转化的? 对于...
  • 线程状态 和进程意义。线程从启动到终止一种由5个状态。分别时创建状态,就绪状态,运行状态,阻塞状态和终止状态状态转换常用方法 创建状态-&amp;gt;(start()方法)-&amp;gt;就绪状态 就绪状态-...
  • java线程状态转化

    2018-03-02 13:48:02
    线程状态图说明:线程共包括以下5种状态。1. 新建状态(New) : 线程对象被创建后,就进入了新建状态。例如,Thread thread = new Thread()。2. 就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后,...
  • Java线程6种状态: 1.new(初始化):start()方法转runnable 2.runnable(可执行/执行): 等待synchronized 的隐式锁时转blocked 3.blocked(阻塞): 当等待的线程获得 synchronized 隐式锁时,就又会从 BLOCKED 转换到 ...
  • (多选)在Java线程状态转换时,下列转换不可能发生的有()? A. 初始态->运行态 B. 就绪态->运行态 C. 阻塞态->运行态 D. 运行态->就绪态
  • 状态线程位于可运行线程池中,等待被线程调度选中,获取cpu 的使用权 。运行(running):可运行状态(runnable)的线程获得了cpu 时间片(timeslice) ,执行程序代码。阻塞(block):阻塞状态是指线程因为某种原因...
  • 线程状态 Thread.State 状态类型 在指定的时间点, 一个线程有且只有一种状态。 这些状态是 JVM 的状态, 他们并没有反映操作系统的状态。 定义 Thread 的状态是定义在 Thread 内部的枚举类型。...
  • Java线程状态转换流程,读懂此,绝对会对多线程理解大大加深 1、新建状态(New):新创建了一个线程对象。 2、就绪状态(Runnable):线程对象创建后,其他线程调用了该对象的start()方法。该状态的线程位于...
  • Java线程状态及其转换

    2020-03-26 15:05:38
    线程状态及其转换 一、线程状态 Java中定义线程的状态有6种,可以查看Thread类的State枚举: public static enum State { NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED; private State() {} }...
  • Java多线程--线程状态之间的转换

    千次阅读 2017-09-03 17:51:35
    线程状态图 说明: 线程共包括以下5种状态。 1. 新建状态(New) : 线程对象被创建后,就进入了新建状态。例如,Thread thread = new Thread()。 2. 就绪状态(Runnable): 也被称为“可执行状态”。线程对象被...
  • 操作系统中的线程状态转换 首先我们来看看操作系统中的线程状态转换。 在现在的操作系统中,线程是被视为轻量级进程的,所以操作系统线程的状态其实和操作系统进程的状态...Java线程的6个状态 // Thread.State 源码 p
  • Java线程状态以及状态转化 NEW 创建线程 TIMED_WAITING 线程无限等待或者超时等待 WATING 线程等待 RUNNABLE 线程处于运行态(RUNNING)或者就绪态(READY) TERMINATED 终止 BLOCKED 锁 线程阻塞 [外链图片转存...
  • 添加链接描述
  • 大家好,我是李小墨,be foolish,be hungry。本篇文章主要写java线程状态转换,欢迎大家多多斧正,如果觉得小墨我写得用心的话,可以点个赞啊。 主要讲述java线程状态转换,参入使用少量代码
  • 二、Java线程的6个状态 public enum State { NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED; } 1.NEW 处于NEW状态的线程,代表线程创建成功,但并未启动。这里的未启动,指
  • Java线程状态转换

    2020-10-29 18:56:34
    线程状态
  • 线程状态转换及各部分介绍

    千次阅读 2019-04-11 22:13:14
    线程状态转换 线程的几种状态 新建状态(New): 用new语句创建的线程处于新建状态,此时它和其他Java对象一样,仅仅在堆区中被分配了内存。 就绪状态(Runnable): 当一个线程对象创建后,其他线程调用它的...
  • 常说的线程Java线程 学会线程状态转换能做什么? Java体系和计算机系统联系起来 定位问题有理论支持 常说的线程 进程是操作系统分配资源的最小单位, 线程是操作系统调度的最小单位. 一个进程可以包含多个线程, 所以...
  • 线程间的状态转换:  1. 新建(new):新创建了一个线程对象。 2. 可运行(runnable):线程对象创建后,其他线程(比如main线程)调用了该对象的start()方法。该状态线程位于可运行线程池中,等待被线程...
  • Java线程的6种状态变化及其变化1、线程的6种状态2、线程的6种状态转化 1、线程的6种状态 状态 描述 NEW(新建) 创建了线程对象但是没有调用start方法启动的状态 Runnable(可运行) 线程调用了start...
  • 白话java锁--线程状态

    2019-07-30 18:18:21
    这里注意一下java线程是映射到操作系统的线程的,在执行线程操作的时候实际上是需要调用操作系统的方法的 创建线程的四种方式 方式一 继承Thread类 public class MyThread extends Thread 注意: 一个线程调用两...
  • 运行(RUNNABLE):Java线程中将就绪(ready)和运行中(running)两种状态笼统的称为“运行”。线程对象创建后,其他线程(比如main线程)调用了该对象的start()方法。该状态的线程位于可运行线程池中,等待被线程...
  • Java线程状态

    2018-06-08 08:33:33
    对于线程状态的分类并没有严格的规定,只要能正确表示状态即可,如,先看其中一种状态分类,一个线程从创建到死亡可能会经历若干个状态,但在任意一个时间点线程只能处于其中一种状态,总共包含五个状态:新建...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 52,828
精华内容 21,131
关键字:

java线程状态转化图

java 订阅