精华内容
下载资源
问答
  • 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

     

    展开全文
  • 线程状态图说明:线程共包括以下5种状态。1.新建状态(New): 线程对象被创建后,就进入了新建状态。例如,Thread thread = new Thread()。2.就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后,其它线程...

    线程状态图

    e42edf8b13f80e8491a3dcd2de46038e.png

    说明:

    线程共包括以下5种状态。

    1. 新建状态(New): 线程对象被创建后,就进入了新建状态。例如,Thread thread = new Thread()。

    2. 就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后,其它线程调用了该对象的start()方法,从而来启动该线程。例如,thread.start()。处于就绪状态的线程,随时可能被CPU调度执行。

    3. 运行状态(Running) : 线程获取CPU权限进行执行。需要注意的是,线程只能从就绪状态进入到运行状态。

    4. 阻塞状态(Blocked) : 阻塞状态是线程因为某种原因放弃CPU使用权,暂时停止运行。直到线程进入就绪状态,才有机会转到运行状态。阻塞的情况分三种:

    (01) 等待阻塞 -- 通过调用线程的wait()方法,让线程等待某工作的完成。

    (02) 同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用),它会进入同步阻塞状态。

    (03) 其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时,线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。

    5. 死亡状态(Dead)    : 线程执行完了或者因异常退出了run()方法,该线程结束生命周期。

    1. wait(), notify(), notifyAll()等方法介绍

    在Object.java中,定义了wait(), notify()和notifyAll()等接口。wait()的作用是让当前线程进入等待状态,同时,wait()也会让当前线程释放它所持有的锁。而notify()和notifyAll()的作用,则是唤醒当前对象上的等待线程;notify()是唤醒单个线程,而notifyAll()是唤醒所有的线程。

    Object类中关于等待/唤醒的API详细信息如下:

    notify()-- 唤醒在此对象监视器上等待的单个线程。

    notifyAll()  -- 唤醒在此对象监视器上等待的所有线程。

    wait()                               -- 让当前线程处于“等待(阻塞)状态”,“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法”,当前线程被唤醒(进入“就绪状态”)。

    wait(long timeout)                -- 让当前线程处于“等待(阻塞)状态”,“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法,或者超过指定的时间量”,当前线程被唤醒(进入“就绪状态”)。

    wait(long timeout, int nanos)-- 让当前线程处于“等待(阻塞)状态”,“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法,或者其他某个线程中断当前线程,或者已超过某个实际时间量”,当前线程被唤醒(进入“就绪状态”)。

    2. 为什么notify(), wait()等函数定义在Object中,而不是Thread中

    Object中的wait(), notify()等函数,和synchronized一样,会对“对象的同步锁”进行操作。

    wait()会使“当前线程”等待,因为线程进入等待状态,所以线程应该释放它锁持有的“同步锁”,否则其它线程获取不到该“同步锁”而无法运行!

    OK,线程调用wait()之后,会释放它锁持有的“同步锁”;而且,根据前面的介绍,我们知道:等待线程可以被notify()或notifyAll()唤醒。现在,请思考一个问题:notify()是依据什么唤醒等待线程的?或者说,wait()等待线程和notify()之间是通过什么关联起来的?答案是:依据“对象的同步锁”。

    负责唤醒等待线程的那个线程(我们称为“唤醒线程”),它只有在获取“该对象的同步锁”(这里的同步锁必须和等待线程的同步锁是同一个),并且调用notify()或notifyAll()方法之后,才能唤醒等待线程。虽然,等待线程被唤醒;但是,它不能立刻执行,因为唤醒线程还持有“该对象的同步锁”。必须等到唤醒线程释放了“对象的同步锁”之后,等待线程才能获取到“对象的同步锁”进而继续运行。

    总之,notify(), wait()依赖于“同步锁”,而“同步锁”是对象锁持有,并且每个对象有且仅有一个!这就是为什么notify(), wait()等函数定义在Object类,而不是Thread类中的原因。

    3. yield()介绍

    yield()的作用是让步。它能让当前线程由“运行状态”进入到“就绪状态”,从而让其它具有相同优先级的等待线程获取执行权;但是,并不能保证在当前线程调用yield()之后,其它具有相同优先级的线程就一定能获得执行权;也有可能是当前线程又进入到“运行状态”继续运行!

    4. yield() 与 wait()的比较

    我们知道,wait()的作用是让当前线程由“运行状态”进入“等待(阻塞)状态”的同时,也会释放同步锁。而yield()的作用是让步,它也会让当前线程离开“运行状态”。它们的区别是:

    (01) wait()是让线程由“运行状态”进入到“等待(阻塞)状态”,而不yield()是让线程由“运行状态”进入到“就绪状态”。

    (02) wait()是会线程释放它所持有对象的同步锁,而yield()方法不会释放锁。

    //YieldLockTest.java 的源码

    public classYieldLockTest{private static Object obj = newObject();public static voidmain(String[] args){

    ThreadA t1= new ThreadA("t1");

    ThreadA t2= new ThreadA("t2");

    t1.start();

    t2.start();

    }static class ThreadA extendsThread{publicThreadA(String name){super(name);

    }public voidrun(){//获取obj对象的同步锁

    synchronized(obj) {for(int i=0; i <10; i++){

    System.out.printf("%s [%d]:%d\n", this.getName(), this.getPriority(), i);//i整除4时,调用yield

    if (i%4 == 0)

    Thread.yield();

    }

    }

    }

    }

    }

    (某一次)运行结果:

    t1 [5]:0t1 [5]:1t1 [5]:2t1 [5]:3t1 [5]:4t1 [5]:5t1 [5]:6t1 [5]:7t1 [5]:8t1 [5]:9t2 [5]:0t2 [5]:1t2 [5]:2t2 [5]:3t2 [5]:4t2 [5]:5t2 [5]:6t2 [5]:7t2 [5]:8t2 [5]:9

    结果说明:

    主线程main中启动了两个线程t1和t2。t1和t2在run()会引用同一个对象的同步锁,即synchronized(obj)。在t1运行过程中,虽然它会调用Thread.yield();但是,t2是不会获取cpu执行权的。因为,t1并没有释放“obj所持有的同步锁”!

    5. sleep()介绍

    sleep() 定义在Thread.java中。

    sleep() 的作用是让当前线程休眠,即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间,线程休眠的时间会大于/等于该休眠时间;在线程重新被唤醒时,它会由“阻塞状态”变成“就绪状态”,从而等待cpu的调度执行。

    6. sleep() 与 wait()的比较

    我们知道,wait()的作用是让当前线程由“运行状态”进入“等待(阻塞)状态”的同时,也会释放同步锁。而sleep()的作用是也是让当前线程由“运行状态”进入到“休眠(阻塞)状态”。

    但是,wait()会释放对象的同步锁,而sleep()则不会释放锁。

    下面通过示例演示sleep()是不会释放锁的。

    //SleepLockTest.java的源码

    public classSleepLockTest{private static Object obj = newObject();public static voidmain(String[] args){

    ThreadA t1= new ThreadA("t1");

    ThreadA t2= new ThreadA("t2");

    t1.start();

    t2.start();

    }static class ThreadA extendsThread{publicThreadA(String name){super(name);

    }public voidrun(){//获取obj对象的同步锁

    synchronized(obj) {try{for(int i=0; i <10; i++){

    System.out.printf("%s: %d\n", this.getName(), i);//i能被4整除时,休眠100毫秒

    if (i%4 == 0)

    Thread.sleep(100);

    }

    }catch(InterruptedException e) {

    e.printStackTrace();

    }

    }

    }

    }

    }

    主线程main中启动了两个线程t1和t2。t1和t2在run()会引用同一个对象的同步锁,即synchronized(obj)。在t1运行过程中,虽然它会调用Thread.sleep(100);但是,t2是不会获取cpu执行权的。因为,t1并没有释放“obj所持有的同步锁”!

    注意,若我们注释掉synchronized (obj)后再次执行该程序,t1和t2是可以相互切换的。

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

    2019-06-07 22:32:47
    文章目录线程状态图说明:线程共包括以下5种状态。1. wait(), notify(), notifyAll()等方法介绍2. 为什么notify(), wait()等函数定义在Object中,而不是Thread中3. yield()介绍4. yield() 与 wait()的比较 线程状态...

    线程状态图

    在这里插入图片描述

    说明:

    线程共包括以下5种状态。

    1. 新建状态(New) : 线程对象被创建后,就进入了新建状态。例如,Thread thread = new Thread()。
    2. 就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后,其它线程调用了该对象的start()方法,从而来启动该线程。例如,thread.start()。处于就绪状态的线程,随时可能被CPU调度执行。
    3. 运行状态(Running) : 线程获取CPU权限进行执行。需要注意的是,线程只能从就绪状态进入到运行状态。
    4. 阻塞状态(Blocked) : 阻塞状态是线程因为某种原因放弃CPU使用权,暂时停止运行。直到线程进入就绪状态,才有机会转到运行状态。阻塞的情况分三种:
      (01) 等待阻塞 – 通过调用线程的wait()方法,让线程等待某工作的完成。
      (02) 同步阻塞 – 线程在获取synchronized同步锁失败(因为锁被其它线程所占用),它会进入同步阻塞状态。
      (03) 其他阻塞 – 通过调用线程的sleep()或join()或发出了I/O请求时,线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。
    5. 死亡状态(Dead) : 线程执行完了或者因异常退出了run()方法,该线程结束生命周期。

    1. wait(), notify(), notifyAll()等方法介绍

    在Object.java中,定义了wait(), notify()和notifyAll()等接口。wait()的作用是让当前线程进入等待状态,同时,wait()也会让当前线程释放它所持有的锁。而notify()和notifyAll()的作用,则是唤醒当前对象上的等待线程;notify()是唤醒单个线程,而notifyAll()是唤醒所有的线程。

    Object类中关于等待/唤醒的API详细信息如下:

    notify() – 唤醒在此对象监视器上等待的单个线程。
    notifyAll() – 唤醒在此对象监视器上等待的所有线程。
    wait() – 让当前线程处于“等待(阻塞)状态”,“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法”,当前线程被唤醒(进入“就绪状态”)。
    wait(long timeout) – 让当前线程处于“等待(阻塞)状态”,“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法,或者超过指定的时间量”,当前线程被唤醒(进入“就绪状态”)。
    wait(long timeout, int nanos) – 让当前线程处于“等待(阻塞)状态”,“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法,或者其他某个线程中断当前线程,或者已超过某个实际时间量”,当前线程被唤醒(进入“就绪状态”)。


    2. 为什么notify(), wait()等函数定义在Object中,而不是Thread中

    Object中的wait(), notify()等函数,和synchronized一样,会对“对象的同步锁”进行操作。

    wait()会使“当前线程”等待,因为线程进入等待状态,所以线程应该释放它锁持有的“同步锁”,否则其它线程获取不到该“同步锁”而无法运行!
    OK,线程调用wait()之后,会释放它锁持有的“同步锁”;而且,根据前面的介绍,我们知道:等待线程可以被notify()或notifyAll()唤醒。现在,请思考一个问题:notify()是依据什么唤醒等待线程的?或者说,wait()等待线程和notify()之间是通过什么关联起来的?答案是:依据“对象的同步锁”。

    负责唤醒等待线程的那个线程(我们称为“唤醒线程”),它只有在获取“该对象的同步锁”(这里的同步锁必须和等待线程的同步锁是同一个),并且调用notify()或notifyAll()方法之后,才能唤醒等待线程。虽然,等待线程被唤醒;但是,它不能立刻执行,因为唤醒线程还持有“该对象的同步锁”。必须等到唤醒线程释放了“对象的同步锁”之后,等待线程才能获取到“对象的同步锁”进而继续运行。

    总之,notify(), wait()依赖于“同步锁”,而“同步锁”是对象锁持有,并且每个对象有且仅有一个!这就是为什么notify(), wait()等函数定义在Object类,而不是Thread类中的原因。


    3. yield()介绍

    yield()的作用是让步。它能让当前线程由“运行状态”进入到“就绪状态”,从而让其它具有相同优先级的等待线程获取执行权;但是,并不能保证在当前线程调用yield()之后,其它具有相同优先级的线程就一定能获得执行权;也有可能是当前线程又进入到“运行状态”继续运行!


    4. yield() 与 wait()的比较

    我们知道,wait()的作用是让当前线程由“运行状态”进入“等待(阻塞)状态”的同时,也会释放同步锁。而yield()的作用是让步,它也会让当前线程离开“运行状态”。它们的区别是:
    (01) wait()是让线程由“运行状态”进入到“等待(阻塞)状态”,而不yield()是让线程由“运行状态”进入到“就绪状态”。
    (02) wait()是会线程释放它所持有对象的同步锁,而yield()方法不会释放锁。

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

    2018-03-02 13:48:02
    线程状态图说明:线程共包括以下5种状态。1. 新建状态(New) : 线程对象被创建后,就进入了新建状态。例如,Thread thread = new Thread()。2. 就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后,...

    线程状态图

    说明
    线程共包括以下5种状态。
    1. 新建状态(New)         : 线程对象被创建后,就进入了新建状态。例如,Thread thread = new Thread()。
    2. 就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后,其它线程调用了该对象的start()方法,从而来启动该线程。例如,thread.start()。处于就绪状态的线程,随时可能被CPU调度执行。
    3. 运行状态(Running) : 线程获取CPU权限进行执行。需要注意的是,线程只能从就绪状态进入到运行状态。
    4. 阻塞状态(Blocked)  : 阻塞状态是线程因为某种原因放弃CPU使用权,暂时停止运行。直到线程进入就绪状态,才有机会转到运行状态。阻塞的情况分三种:
        (01) 等待阻塞 -- 通过调用线程的wait()方法,让线程等待某工作的完成。
        (02) 同步阻塞 -- 线程在获取synchronized同步锁失败(因为锁被其它线程所占用),它会进入同步阻塞状态。
        (03) 其他阻塞 -- 通过调用线程的sleep()或join()或发出了I/O请求时,线程会进入到阻塞状态。当sleep()状态超时、join()等待线程终止或者超时、或者I/O处理完毕时,线程重新转入就绪状态。
    5. 死亡状态(Dead)    : 线程执行完了或者因异常退出了run()方法,该线程结束生命周期。

     

    1. wait(), notify(), notifyAll()等方法介绍

    在Object.java中,定义了wait(), notify()和notifyAll()等接口。wait()的作用是让当前线程进入等待状态,同时,wait()也会让当前线程释放它所持有的锁。而notify()和notifyAll()的作用,则是唤醒当前对象上的等待线程;notify()是唤醒单个线程,而notifyAll()是唤醒所有的线程。

    Object类中关于等待/唤醒的API详细信息如下:
    notify()        -- 唤醒在此对象监视器上等待的单个线程。
    notifyAll()   -- 唤醒在此对象监视器上等待的所有线程。
    wait()                                         -- 让当前线程处于“等待(阻塞)状态”,“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法”,当前线程被唤醒(进入“就绪状态”)。
    wait(long timeout)                    -- 让当前线程处于“等待(阻塞)状态”,“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法,或者超过指定的时间量”,当前线程被唤醒(进入“就绪状态”)。
    wait(long timeout, int nanos)  -- 让当前线程处于“等待(阻塞)状态”,“直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法,或者其他某个线程中断当前线程,或者已超过某个实际时间量”,当前线程被唤醒(进入“就绪状态”)。

    2. 为什么notify(), wait()等函数定义在Object中,而不是Thread中

    Object中的wait(), notify()等函数,和synchronized一样,会对“对象的同步锁”进行操作。

    wait()会使“当前线程”等待,因为线程进入等待状态,所以线程应该释放它锁持有的“同步锁”,否则其它线程获取不到该“同步锁”而无法运行!
    OK,线程调用wait()之后,会释放它锁持有的“同步锁”;而且,根据前面的介绍,我们知道:等待线程可以被notify()或notifyAll()唤醒。现在,请思考一个问题:notify()是依据什么唤醒等待线程的?或者说,wait()等待线程和notify()之间是通过什么关联起来的?答案是:依据“对象的同步锁”。

    负责唤醒等待线程的那个线程(我们称为“唤醒线程”),它只有在获取“该对象的同步锁”(这里的同步锁必须和等待线程的同步锁是同一个),并且调用notify()或notifyAll()方法之后,才能唤醒等待线程。虽然,等待线程被唤醒;但是,它不能立刻执行,因为唤醒线程还持有“该对象的同步锁”。必须等到唤醒线程释放了“对象的同步锁”之后,等待线程才能获取到“对象的同步锁”进而继续运行。

    总之,notify(), wait()依赖于“同步锁”,而“同步锁”是对象锁持有,并且每个对象有且仅有一个!这就是为什么notify(), wait()等函数定义在Object类,而不是Thread类中的原因。

     3. yield()介绍

    yield()的作用是让步。它能让当前线程由“运行状态”进入到“就绪状态”,从而让其它具有相同优先级的等待线程获取执行权;但是,并不能保证在当前线程调用yield()之后,其它具有相同优先级的线程就一定能获得执行权;也有可能是当前线程又进入到“运行状态”继续运行!

    4. yield() 与 wait()的比较

    我们知道,wait()的作用是让当前线程由“运行状态”进入“等待(阻塞)状态”的同时,也会释放同步锁。而yield()的作用是让步,它也会让当前线程离开“运行状态”。它们的区别是:
    (01) wait()是让线程由“运行状态”进入到“等待(阻塞)状态”,而不yield()是让线程由“运行状态”进入到“就绪状态”。
    (02) wait()是会线程释放它所持有对象的同步锁,而yield()方法不会释放锁。

    复制代码
    // YieldLockTest.java 的源码
    public class YieldLockTest{ 
    
        private static Object obj = new Object();
    
        public static void main(String[] args){ 
            ThreadA t1 = new ThreadA("t1"); 
            ThreadA t2 = new ThreadA("t2"); 
            t1.start(); 
            t2.start();
        } 
    
        static class ThreadA extends Thread{
            public ThreadA(String name){ 
                super(name); 
            } 
            public void run(){ 
                // 获取obj对象的同步锁
                synchronized (obj) {
                    for(int i=0; i <10; i++){ 
                        System.out.printf("%s [%d]:%d\n", this.getName(), this.getPriority(), i); 
                        // i整除4时,调用yield
                        if (i%4 == 0)
                            Thread.yield();
                    }
                }
            } 
        } 
    }
    复制代码

    (某一次)运行结果

    复制代码
    t1 [5]:0
    t1 [5]:1
    t1 [5]:2
    t1 [5]:3
    t1 [5]:4
    t1 [5]:5
    t1 [5]:6
    t1 [5]:7
    t1 [5]:8
    t1 [5]:9
    t2 [5]:0
    t2 [5]:1
    t2 [5]:2
    t2 [5]:3
    t2 [5]:4
    t2 [5]:5
    t2 [5]:6
    t2 [5]:7
    t2 [5]:8
    t2 [5]:9
    复制代码

    结果说明
    主线程main中启动了两个线程t1和t2。t1和t2在run()会引用同一个对象的同步锁,即synchronized(obj)。在t1运行过程中,虽然它会调用Thread.yield();但是,t2是不会获取cpu执行权的。因为,t1并没有释放“obj所持有的同步锁”!

    5. sleep()介绍

    sleep() 定义在Thread.java中。
    sleep() 的作用是让当前线程休眠,即当前线程会从“运行状态”进入到“休眠(阻塞)状态”。sleep()会指定休眠时间,线程休眠的时间会大于/等于该休眠时间;在线程重新被唤醒时,它会由“阻塞状态”变成“就绪状态”,从而等待cpu的调度执行。

    6. sleep() 与 wait()的比较

    我们知道,wait()的作用是让当前线程由“运行状态”进入“等待(阻塞)状态”的同时,也会释放同步锁。而sleep()的作用是也是让当前线程由“运行状态”进入到“休眠(阻塞)状态”。
    但是,wait()会释放对象的同步锁,而sleep()则不会释放锁。
    下面通过示例演示sleep()是不会释放锁的。

    复制代码
    // SleepLockTest.java的源码
    public class SleepLockTest{ 
    
        private static Object obj = new Object();
    
        public static void main(String[] args){ 
            ThreadA t1 = new ThreadA("t1"); 
            ThreadA t2 = new ThreadA("t2"); 
            t1.start(); 
            t2.start();
        } 
    
        static class ThreadA extends Thread{
            public ThreadA(String name){ 
                super(name); 
            } 
            public void run(){ 
                // 获取obj对象的同步锁
                synchronized (obj) {
                    try {
                        for(int i=0; i <10; i++){ 
                            System.out.printf("%s: %d\n", this.getName(), i); 
                            // i能被4整除时,休眠100毫秒
                            if (i%4 == 0)
                                Thread.sleep(100);
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            } 
        } 
    }
    复制代码

    主线程main中启动了两个线程t1和t2。t1和t2在run()会引用同一个对象的同步锁,即synchronized(obj)。在t1运行过程中,虽然它会调用Thread.sleep(100);但是,t2是不会获取cpu执行权的。因为,t1并没有释放“obj所持有的同步锁”!
    注意,若我们注释掉synchronized (obj)后再次执行该程序,t1和t2是可以相互切换的。

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

    2019-04-22 15:01:22
    1. wait(), notify(), notifyAll()等方法介绍 2. 为什么notify(), wait()等函数定义在Object中,而不是Thread中 3. yield()介绍 ...线程状态图 说明: 线程共包括以下5种状态。 1.新建状态(N...
  • 4 Java线程的状态及主要转化方法4.1 操作系统中的线程状态转换首先我们来看看操作系统中的线程状态转换。在现在的操作系统中,线程是被视为轻量级进程的,所以操作系统线程的状态其实和操作系统进程的状态是一致的。...
  • 线程状态图 说明: 线程共包括以下5种状态。 新建状态(New) : 线程对象被创建后,就进入了新建状态。例如,Thread thread = new Thread()。 就绪状态(Runnable): 也被称为“可执行状态”。线程对象被创建后,...
  • 关于线程的生命周期,网上书上说法不一...下源自《Java并发编程艺术》4-1一、新建状态(NEW)即用new关键字新建一个线程,这个线程就处于新建状态。二、运行状态(RUNNABLE)操作系统中的就绪和运行两种状态,在Java...
  • 一、线程的5种状态 众所周知,Java线程状态有5种,分别对应上中五种不同颜色,下面对这5种状态及状态间的转化做相应的解释: 1. 初始化状态:新建一个线程对象 2. 可运行状态:其他线程调用了该线程对象的start...
  • Java线程状态

    千次阅读 2014-11-29 19:03:17
    线程跟人类一样拥有自己的生命周期,一条线程从创建到执行完毕的过程即是线程的生命周期,此过程可能在不同时刻处于不同的状态,线程状态正是这小节的主题,线程到底有多少种状态?不同状态之间是如何转化的? 对于...
  • 线程状态转化图: 说明: 线程总共包括以下5种状态。 1、新状态New:该状态也叫新建状态,当线程对象被创建后,线程就进入了新建状态。例如:Thread thread = new Thread();。 2、就绪状态Runnable:该状态也...
  • 线程状态转化图一: 线程转换状态图二: 线程的几种状态: 新建状态(New): 用new语句创建的线程处于新建状态,此时它和其它java对象一样,仅仅在堆中分配了内存。 就绪状态(Runnable): 当一个线程对象被...
  • 一、众所周知,Java线程状态有5种,分别对应上中五种不同颜色,下面对这5种状态及状态间的转化做相应的解释:1.初始化状态:新建一个线程对象2.可运行状态:其他线程调用了该线程对象的start()方法。该状态的...
  • 目录 目录 一、线程的5种状态 ...众所周知,Java线程状态有5种,分别对应上中五种不同颜色,下面对这5种状态及状态间的转化做相应的解释: 1. 初始化状态:新建一个线程对象 2. ...
  • Java线程状态以及状态转化 NEW 创建线程 TIMED_WAITING 线程无限等待或者超时等待 WATING 线程等待 RUNNABLE 线程处于运行态(RUNNING)或者就绪态(READY) TERMINATED 终止 BLOCKED 锁 线程阻塞 [外链图片转存...
  • Java线程状态

    2018-06-08 08:33:33
    对于线程状态的分类并没有严格的规定,只要能正确表示状态即可,如,先看其中一种状态分类,一个线程从创建到死亡可能会经历若干个状态,但在任意一个时间点线程只能处于其中一种状态,总共包含五个状态:新建...
  • 线程的生命周期,把图转化为文字就是:1、线程通过new方法创建,调用start,线程进入就绪状态,等待系统的调度(时间片轮转调度)。当系统调度,进入运行状态。正常结束或者异常退出,进程进入死亡状态。2、处于运行...
  • 一、线程的5种状态 众所周知,Java线程状态有5种,分别对应上中五种不同颜色,下面对这5种状态及状态间的转化做相应的解释: 1. 初始化状态:新建一个线程对象 2. 可运行状态:其他线程调用了该线程对象的start...
  • 线程之间的转化状态

    2018-01-12 00:09:00
    先来一张线程状态转化图: 作者:大闲人柴毛毛链接:https://www.zhihu.com/question/27654579/answer/252912242来源:知乎著作权归作者所有。商业转载请联系作者获得授权,非商业转载请注明出处。 在Java中...
  • java线程的生命周期都有哪些个阶段呢?请看下:     重点是各个状态直接的转化在java代码层面上如何体现,你需要好好理解。 new(初始化状态)     新建一个线程对象。...
  • Java 线程生命周期中都包含哪些状态?生命周期中各个状态都是什么含义?状态是如何转化的?线程的生命周期,对于多线程开发是非常重要的,也是面试中常见的问题。下面我们就梳理一下线程的生命周期,快速理解掌握。...
  • 015 线程状态

    2019-02-25 17:21:00
    JAVA 线程状态转化 线程状态图 说明:线程共包括以下5种状态。1.新建状态(New) : 线程对象被创建后,就进入了新建状态。例如,Thread thread = new Thread()。2.就绪状态(Runnable): 也被称为“可执行...
  • Java 线程生命周期中都包含哪些状态?生命周期中各个状态都是什么含义?状态是如何转化的?线程的生命周期,对于多线程开发是非常重要的,也是面试中常见的问题。下面我们就梳理一下线程的生命周期,快速理解掌握。...
  • 文章目录线程状态划分:以os角度划分为五种以java线程描述关键字来说划分为六种6种线程状态转换分析 线程状态划分: 以os角度划分为五种 如下 初始状态:仅是在语言层面创建了线程对象,还未与操作系统线程关联...
  • java线程(3)-线程的生命周期 1.两种生命周期流转 ** 生命周期:**一个事物冲从出生的那一刻开始到最终死亡中间的过程 在事物的漫长的生命周期过程中,总会经历不同的状态(婴儿状态/青少年状态/中年状态/老年状态) ...
  • Java线程问题总结

    2019-03-20 19:30:00
    一:java线程状态和转化过程 参考:https://www.cnblogs.com/happy-coder/p/6587092.html 线程转化图: 说明:线程共包括以下5种状态。1.新建状态(New) : 线程对象被创建后,就进入了新建状态。例如,Thread ...

空空如也

空空如也

1 2 3 4
收藏数 72
精华内容 28
关键字:

java线程状态转化图

java 订阅