精华内容
下载资源
问答
  • 使用new创建一个线程时,线程还没有开始运行,此时线程处于新建状态一个线程处于新建状态时,程序中的代码还没有开始运行。 就绪状态: 一个新建的线程并不能自动运行,要执行线程必须调用线程的start()...

    新建状态:

    当使用new创建一个线程时,线程还没有开始运行,此时线程处于新建状态。当一个线程处于新建状态时,程序中的代码还没有开始运行。 

    就绪状态:

    一个新建的线程并不能自动运行,要执行线程必须调用线程的start()方法。当线程对象调用start()方法即启动了线程,start()方法创建线程运行的系统资源,并调度线程运行run()方法。当start()方法返回后,线程就处于就绪状态。因为在单CPU的计算机系统中,不可能同时运行多个线程,一个时刻仅有一个线程处于运行状态。因此此时可能有多个线程处于就绪状态。对多个处于就绪状态的线程是由Java运行时系统的线程调度程序(thread scheduler)来调度的。

    运行状态:

    当线程获得CPU时间后,它才进入运行状态,真正开始执行run()方法。

    阻塞状态:

    1>线程通过调用sleep方法进入睡眠状态;
    2>线程调用一个在I/O上被阻塞的操作,即该操作在输入输出操作完成之前不会返回到它的调用者;
    3>线程试图得到一个锁,而该锁正被其他线程持有;
    4>线程在等待某个触发条件;

    死亡状态:

    有两个原因会导致线程死亡:
    1> run方法正常退出而自然死亡,
    2> 一个未捕获的异常终止了run方法而使线程猝死。


    注意:

    1、为了确定线程在当前是否存活着(可运行、被阻塞),需要使用isAlive方法。如果是可运行或被阻塞,这个方法返回true; 如果线程仍旧是new状态且不是可运行的, 或者线程死亡了,则返回false。

    2、join()获取线程执行权

    3、yield()大多数情况下,yield()将导致线程从运行状态转到可运行状态,但有可能没有效果。

    展开全文
  • 前言=====当线程被创建并启动以后,它既不是一启动就进入了执行状态,也不是一直处于执行状态。在线程的生命周期中,它要经过新建(New)、就绪(Runnable)、运行(Running)、阻塞(Blocked)和死亡(Dead)5种状态。尤其是...

    前言

    =====

    当线程被创建并启动以后,它既不是一启动就进入了执行状态,也不是一直处于执行状态。在线程的生命周期中,它要经过新建(New)、就绪(Runnable)、运行(Running)、阻塞(Blocked)和死亡(Dead)5种状态。尤其是当线程启动以后,它不可能一直"霸占"着CPU独自运行,所以CPU需要在多条线程之间切换,于是线程状态也会多次在运行、阻塞之间切换。

    2e4d7d7ee1f89fea55e661f594c513b6.png

    线程状态转换关系

    1 新建(New)状态

    当程序使用new关键字创建了一个线程之后,该线程就处于 新建状态,此时的线程情况如下:

    926800139be81a291c1e4493d071a2da.png

    2 就绪(Runnable)状态

    当线程对象调用了start()方法之后,该线程处于 就绪状态。此时的线程情况如下:

    0ea3e89a3592d78321029e938fe0efd6.png

    调用start()方法与run()方法,对比如下:

    fffe9a5548f1cbfc50c26acae33dd0e8.png

    **如何让子线程调用start()方法之后立即执行而非"等待执行":

    **

    f6682da8ed6fd0ec5764ef1690c420e8.png

    **3 运行(Running)状态

    当CPU开始调度处于 就绪状态 的线程时,此时线程获得了CPU时间片才得以真正开始执行run()方法的线程执行体,则该线程处于 运行状态。

    2c1e29d8527945acc912ce70aba55375.png

    处于运行状态的线程最为复杂,它不可能一直处于运行状态(除非它的线程执行体足够短,瞬间就执行结束了),线程在运行过程中需要被中断,目的是使其他线程获得执行的机会,线程调度的细节取决于底层平台所采用的策略。线程状态可能会变为阻塞状态、就绪状态和死亡状态。比如:

    943e039216f423354bae9b549cb86639.png

    4 阻塞(Blocked)状态

    处于运行状态的线程在某些情况下,让出CPU并暂时停止自己的运行,进入 阻塞状态。

    当发生如下情况时,线程将会进入阻塞状态:

    3c8575033b21d3609f097b0209c7e28f.png

    阻塞状态分类:

    f6139a5e0fb6b7376d2d7a80fb1f12e2.png

    在阻塞状态的线程只能进入就绪状态,无法直接进入运行状态。而就绪和运行状态之间的转换通常不受程序控制,而是由系统线程调度所决定。当处于就绪状态的线程获得处理器资源时,该线程进入运行状态;当处于运行状态的线程失去处理器资源时,该线程进入就绪状态。

    ffd9b7fb490a0db06c19d7149d3cab54.png

    4.1 等待(WAITING)状态

    线程处于无限制等待状态,等待一个特殊的事件来重新唤醒,如:

    c720b40caa0b9be795326126889f54d0.png

    以上两种一旦通过相关事件唤醒线程,线程就进入了就绪(RUNNABLE)状态继续运行。

    4.2 时限等待(TIMED_WAITING)状态

    线程进入了一个时限等待状态,如:

    574b8bdf5f6f9c16111513c97f9cf45f.png

    5 死亡(Dead)状态

    线程会以如下3种方式结束,结束后就处于死亡状态:

    e7acadbb4276ab2f2936f0f962b9ef34.png

    处于死亡状态的线程对象也许是活的,但是,它已经不是一个单独执行的线程。线程一旦死亡,就不能复生。如果在一个死去的线程上调用start()方法,会抛出java.lang.IllegalThreadStateException异常。

    所以,需要注意的是:

    57f467a26d3b5579b94223ac8396e772.png

    5.1 终止(TERMINATED)状态

    线程执行完毕后,进入终止(TERMINATED)状态。

    6 线程相关方法

    4da406c259431f521533268cc0006a51.png

    format,png

    线程方法状态转换

    6.1 线程就绪、运行和死亡状态转换

    就绪状态转换为运行状态:此线程得到CPU资源;

    运行状态转换为就绪状态:此线程主动调用yield()方法或在运行过程中失去CPU资源。

    运行状态转换为死亡状态:此线程执行执行完毕或者发生了异常;

    注意:

    6257a57bb5953fbc5b6d0ca99db06d90.png

    6.2 run & start

    通过调用start启动线程,线程执行时会执行run方法中的代码。

    9cfdaa6f391ef61fe766e6bfa914b949.png

    6.3 sleep & yield

    sleep():通过sleep(millis)使线程进入休眠一段时间,该方法在指定的时间内无法被唤醒,同时也不会释放对象锁;

    比如,我们想要使主线程每休眠100毫秒,然后再打印出数字:

    d12cdaf91eeba836c28f810f57e655ca.png

    注意如下几点问题:

    sleep是静态方法,最好不要用Thread的实例对象调用它,因为它睡眠的始终是当前正在运行的线程,而不是调用它的线程对象,它只对正在运行状态的线程对象有效。看下面的例子:

    985c8e829b883d567d18360fdf387010.png

    Java线程调度是Java多线程的核心,只有良好的调度,才能充分发挥系统的性能,提高程序的执行效率。但是不管程序员怎么编写调度,只能最大限度的影响线程执行的次序,而不能做到精准控制。因为使用sleep方法之后,线程是进入阻塞状态的,只有当睡眠的时间结束,才会重新进入到就绪状态,而就绪状态进入到运行状态,是由系统控制的,我们不可能精准的去干涉它,所以如果调用Thread.sleep(1000)使得线程睡眠1秒,可能结果会大于1秒。

    60614391cbf6443dae3d6dacd05daf88.png

    看某一次的运行结果:可以发现,线程0首先执行,然后线程1执行一次,又了执行一次。发现并不是按照sleep的顺序执行的。

    d127de8432cc6713328760b151a94e58.png

    yield():与sleep类似,也是Thread类提供的一个静态的方法,它也可以让当前正在执行的线程暂停,让出CPU资源给其他的线程。但是和sleep()方法不同的是,它不会进入到阻塞状态,而是进入到就绪状态。yield()方法只是让当前线程暂停一下,重新进入就绪线程池中,让系统的线程调度器重新调度器重新调度一次,完全可能出现这样的情况:当某个线程调用yield()方法之后,线程调度器又将其调度出来重新进入到运行状态执行。

    560f4b140fb45cf86c8b33431f5f5155.png

    c55e20bc4979d0a723cf2f37cf787053.png

    关于sleep()方法和yield()方的区别如下:

    03ce2a329c728719b8336ed78248b574.png

    6.4 join

    线程的合并的含义就是将几个并行线程的线程合并为一个单线程执行,应用场景是当一个线程必须等待另一个线程执行完毕才能执行时,Thread类提供了join方法来完成这个功能,注意,它不是静态方法。

    join有3个重载的方法:

    38fecfc32d1c4b1e4f633daf471d4420.png

    例子代码,如下:

    2277b95f13dd831bde714ab617b08770.png

    在JDK中join方法的源码,如下:

    39713d39df63d47f347cae0de48f16af.png

    join方法实现是通过调用wait方法实现。当main线程调用t.join时候,main线程会获得线程对象t的锁(wait 意味着拿到该对象的锁),调用该对象的wait(等待时间),直到该对象唤醒main线程,比如退出后。这就意味着main 线程调用t.join时,必须能够拿到线程t对象的锁。

    6.5 suspend & resume (已过时)

    suspend-线程进入阻塞状态,但不会释放锁。此方法已不推荐使用,因为同步时不会释放锁,会造成死锁的问题。

    resume-使线程重新进入可执行状态。

    为什么 Thread.suspend 和 Thread.resume 被废弃了?

    Thread.suspend 天生容易引起死锁。如果目标线程挂起时在保护系统关键资源的监视器上持有锁,那么其他线程在目标线程恢复之前都无法访问这个资源。如果要恢复目标线程的线程在调用 resume 之前试图锁定这个监视器,死锁就发生了。这种死锁一般自身表现为“冻结( frozen )”进程。

    6.6 stop(已过时)

    不推荐使用,且以后可能去除,因为它不安全。为什么 Thread.stop 被废弃了?

    因为其天生是不安全的。停止一个线程会导致其解锁其上被锁定的所有监视器(监视器以在栈顶产生ThreadDeath异常的方式被解锁)。如果之前被这些监视器保护的任何对象处于不一致状态,其它线程看到的这些对象就会处于不一致状态。这种对象被称为受损的 (damaged)。当线程在受损的对象上进行操作时,会导致任意行为。这种行为可能微妙且难以检测,也可能会比较明显。

    不像其他未受检的(unchecked)异常, ThreadDeath 悄无声息的杀死及其他线程。因此,用户得不到程序可能会崩溃的警告。崩溃会在真正破坏发生后的任意时刻显现,甚至在数小时或数天之后。

    6.7 wait & notify/notifyAll

    wait & notify/notifyAll这三个都是Object类的方法。使用 wait ,notify 和 notifyAll前提是先获得调用对象的锁。

    469259bb77ba1fa4581f027e9d83f185.png

    前面一直提到两个概念,等待队列(等待池),同步队列(锁池),这两者是不一样的。具体如下:

    43a798ab81d785d2d23b47fd49ee8be9.png

    被notify或notifyAll唤起的线程是有规律的,具体如下:

    b8e8eb8e363fe295e97b103c7869685f.png

    6.8 线程优先级

    每个线程执行时都有一个优先级的属性,优先级高的线程可以获得较多的执行机会,而优先级低的线程则获得较少的执行机会。与线程休眠类似,线程的优先级仍然无法保障线程的执行次序。只不过,优先级高的线程获取CPU资源的概率较大,优先级低的也并非没机会执行。

    016ab46e11706bb4cd8b644660cae3a3.png

    Thread类提供了setPriority(int newPriority)和getPriority()方法来设置和返回一个指定线程的优先级,其中setPriority方法的参数是一个整数,范围是1~10之间,也可以使用Thread类提供的三个静态常量:

    2f7ddd4b51ebd5831e38dfe6a528906f.png

    例子代码,如下:

    bfd45d99b501a3794e88e584d686ad97.png

    从执行结果可以看到 ,一般情况下,高级线程更显执行完毕。

    注意一点:

    13e54a0092e59aa7a4a1baf49dbaea51.png

    6.9 守护线程

    守护线程与普通线程写法上基本没啥区别,调用线程对象的方法setDaemon(true),则可以将其设置为守护线程。

    守护线程使用的情况较少,但并非无用,举例来说,JVM的垃圾回收、内存管理等线程都是守护线程。还有就是在做数据库应用时候,使用的数据库连接池,连接池本身也包含着很多后台线程,监控连接个数、超时时间、状态等等。

    setDaemon方法详细说明:

    fa17e9054e546188ec701017ebb3ae5a.png

    执行结果:

    36915e52d6fc4f6ae5e8ca5296ae2659.png

    从上面的执行结果可以看出:前台线程是保证执行完毕的,后台线程还没有执行完毕就退出了。

    8886aaadee9698946678b3bc3c61ff57.png

    6.10 如何结束一个线程

    Thread.stop()、Thread.suspend、Thread.resume、Runtime.runFinalizersOnExit这些终止线程运行的方法已经被废弃了,使用它们是极端不安全的!想要安全有效的结束一个线程,可以使用下面的方法。

    f557ae181348d019a99c6fc3fbc482e1.png

    比如run方法这样写:只要保证在一定的情况下,run方法能够执行完毕即可。而不是while(true)的无限循环。

    0fb3254da8afcc6654619e087b478c30.png

    诚然,使用上面方法的标识符来结束一个线程,是一个不错的方法,但其也有弊端,如果该线程是处于sleep、wait、join的状态时候,while循环就不会执行,那么我们的标识符就无用武之地了,当然也不能再通过它来结束处于这3种状态的线程了。

    所以,此时可以使用interrupt这个巧妙的方式结束掉这个线程。我们先来看看sleep、wait、join方法的声明:

    2729a67757dbb319a5a1f2c78bb4e117.png

    可以看到,这三者有一个共同点,都抛出了一个InterruptedException的异常。在什么时候会产生这样一个异常呢?

    2a8c860552d9034d377b400bdc0e7cda.png

    看下面的简单的例子:

    579c089c090089b69c623113b2a3024c.png

    测试结果:

    806b73487f41cb0e50a9af2cdfc3a7a9.png

    可以看到,首先执行第一次while循环,在第一次循环中,睡眠2秒,然后将中断状态设置为true。当进入到第二次循环的时候,中断状态就是第一次设置的true,当它再次进入sleep的时候,马上就抛出了InterruptedException异常,然后被我们捕获了。然后中断状态又被重新自动设置为false了(从最后一条输出可以看出来)。

    所以,我们可以使用interrupt方法结束一个线程。具体使用如下:

    4ed6770082834b7539334ed6ccf40943.png

    多测试几次,会发现一般有两种执行结果:

    d41bcfb860105b8759add8a0a75b0063.png

    或者

    689e3f76ff9f307a217778bc5360c4b1.png

    这两种结果恰恰说明了,只要一个线程的中断状态一旦为true,只要它进入sleep等状态,或者处于sleep状态,立马回抛出InterruptedException异常。

    b17dcdf1bc9a4f4ded587ba86d3ba8e9.png

    展开全文
  • 线程的生命周期图片来自:https://www.cnblogs.com/sunddenly/p/4106562.html如上图所示,...新建状态程序使用new关键字创建了一个线程之后,该线程处于新建状态,此时仅由JVM为其分配内存,并初始化其成员...

    线程的生命周期

    841b5c68d6344bd8dfaa93f541c39405.png

    图片来自:https://www.cnblogs.com/sunddenly/p/4106562.html

    如上图所示,线程一共有新建(New)就绪(Runnable)运行(Running)阻塞(Blocked)死亡(Dead)5种状态。状态之间的切换如上图所示。

    1. 新建状态,当程序使用new关键字创建了一个线程之后,该线程就处于新建状态,此时仅由JVM为其分配内存,并初始化其成员变量的值
    2. 就绪状态,当线程对象调用了start()方法之后,该线程处于就绪状态。Java虚拟机会为其创建方法调用栈和程序计数器,等待调度运行
    3. 运行状态,如果处于就绪状态的线程获得了CPU,开始执行run()方法的线程执行体,则该线程处于运行状态
    4. 阻塞状态,当处于运行状态的线程失去所占用资源之后,便进入阻塞状态
    5. 线程死亡后内存等数据即会被回收。已经死亡的线程不可被再次启动,否则会抛出异常。

    线程状态的控制

    1、线程休眠 Thread.sleep()

    sleep函数会让当前线程暂停一段时间,并进入阻塞状态。此方法不会释放锁

    睡眠结束后线程会进入就绪状态,因此并不一定会立即执行。

    2、线程让步 Thread.yield()

    调用后,当前线程会从运行状态转换为就绪状态,CPU此时会去做其他线程的任务。不过也有可能当前线程刚进入就绪状态就立即转为运行状态。

    3、线程加入/同步 join()

    线程同步会将若干并发线程变为单一线程执行。如果线程A的join()方法被B调用了,则B会等待A执行完毕后才会执行。join()方法可以指定最大的等待时间,如果超过了这个时间,则不再等了,继续并行。

    //玩家线程类
    class PlayerThread extends Thread{
        public String name ;
        public int time ;
        public MyThread(String name, int time){
            this.name = name ;
            this.time = time ;
        }
        run(){
            try{
                Thread.sleep(time);
    
            }catch(Exception e){
            }
            System.out.println(name + "用了" + time + "时间到了");
        }
    }
    
    //庄家类,庄家需要召集四个玩家然后开始打麻将
    public class Banker{
        public static void main(String[] args){
            PlayerThread p1 = new PlayerThread("李小龙",5);
            PlayerThread p2 = new PlayerThread("成龙",10);
            PlayerThread p3 = new PlayerThread("马龙",1);
            PlayerThread p4 = new PlayerThread("狄龙",15);
    
            p1.start();
            p2.start();
            p3.start();
            p4.start();
    
            p1.join();
            p2.join();
            p3.join();
            p4.join();
    
            //下面这段代码需要等到p1,p2,p3,p4线程全部执行完毕之后才会别调用
            System.out.println("人到齐了,开始打麻将!!!");
        }
    }

    模板代码摘自:https://www.jianshu.com/p/19228c30ffed

    4、线程的优先级设置 priority

    每个线程都可以配置一个属性priority,优先级高的线程可以获得更多的执行机会。优先级默认和创建它的父线程一致。其范围是1~10。Thread类中提供了三个静态常量:

    • MAX_PRIORITY = 10 // 高级
    • NORM_PRIORITY = 5 // 普通。main方法默认就是这个。
    • MIN_PRIORITY = 1 // 低级

    5、守护线程 Daemon

    每个线程都可以设置自己是否是守护线程。如果当前线程是守护线程,则它会一直等待其他线程都进入死亡状态时才会死亡。如果当前留下的都是守护线程,则JVM会退出。

    展开全文
  • 线程阻塞

    2012-08-28 17:22:00
    所谓的阻塞,就是线程能够运行,但是某个条件阻止它的运行,当线程处于阻塞状态时,调度器将忽略线程,不会分配给线程任何CPU时间,直到线程重新进入就绪状态,它才有可能执行操作。就绪并代表是在运行啊,所谓的...

         

     所谓的阻塞,就是线程能够运行,但是某个条件阻止它的运行,当线程处于阻塞状态时,调度器将忽略线程,不会分配给线程任何CPU时间,直到线程重新进入就绪状态,它才有可能执行操作。就绪并代表是在运行啊,所谓的就绪,就是可运行也可不运行,只要调度器分配时间片给线程,线程就可以运行,因为我们都知道,调度器是如何分配线程,是不确定的。为什么任务会进入阻塞的状态,一般有以下几个原因:
            1.通过调用sleep(milliseconds)使任务进入休眠状态,在这种情况下,任务在指定的时间内不会运行;
            2.通过调用wait()使线程挂起,直到线程得到了notify()或notifyAll()消息(或者java SE5的java.util.concurrent类库中等价的signal()或signalAll()),线程才会进入就绪状态;
            3.任务在等到某个输入或输出完成;
            4.任务试图在某个对象上调用其同步控制方法,但是对象锁不可用,因为另一个任务已经获取这个锁;
            阻塞的任务是必须终止的,我们不能等待其到达代码中可以检查其状态值的某一点,因而决定让它主动终止,那么就必须强制这个任务跳出阻塞状态。那么怎样使任务跳出阻塞状态?就是中断。中断?没错,就是中断,但是中断是会抛出异常的啊!没问题,只要不抛出就行!Thread.interrupted()提供了离开run()而不抛出异常的方式。为了调用interrupt(),我们就必须持有Thread对象,但是现在java的concurrent类库在避免对Thread对象的直接操作,尽量通过Executor来执行所有操作。如果我们在Executor上调用shutdownNow(),那么它 将发送一个interrupt()调用给它启动的所有线程。为什么呢?因为当我们完成工程中的某个部分或者整个程序时,通常会希望同时关闭某个特定Executor的所有任务。但是我们也想要只中断某个单一的任务,于是就通过调用submit()而不是executor()来启动任务,就可以持有任务的上下文。submit()将返回一个Future<?>,其中有一个未修饰的参数。为什么要用这个泛型的<?>?其实我也对这个感到兴趣,但是一时半会还是理解不了,所以先放一边吧。持有这种Future的关键在于可以在其上调用cancel(),因此可以使用它来中断某个特定的任务,如果我们将true传递给cancel(),那么就会拥有在该线程上调用interrupt()以停止这个线程的权限。所以,cancel()是一种中断由Executor启动的单个线程的方式。如:
           Future<?> f = exec.submit(RunnableClass);
           f.cancel(true);
           但是我们要注意,不是所有阻塞都可以被中断的,第一种情况可以被中断,但是第3和第4种是不可以被中断的,至于第2种有待研究。
           第3种的解决方案就是利用各种nio类来使阻塞的nio通道自动响应中断。对于第4种,使用显示的ReentrantLock对象,因为在它上面阻塞的任务是具备可以被中断的能力,这与在synchronized方法或临界区上阻塞的任务完全不同。这时我们可以直接调用interrupt()来中断被阻塞的任务,如:lock.interrupt();
           当我们在线程上调用interrupt()时,中断发生的唯一时刻是在任务要进入到阻塞操作中,或者已经在阻塞操作内部时,但是如果根据程序运行的环境,我们可能已经编写了可能会产生这种阻塞调用的代码,那么该怎么办?如果我们只能通过调用在阻塞调用上抛出异常来退出,那么我们就无法总是可以离开run()循环。因此如果调用interrupt()已停止某个任务,那么在run()循环碰巧没有产生任何阻塞调用的情况下,我们的任务就需要第二种方式来退出。于是我们就需要利用中断状态。中断状态是可以通过调用interrupted()来检查中断状态,这不仅可以告诉我们interrupt()是否被调用过,而且还可以清除中断状态。清除中断状态可以确保并发结构不会就某个任务被中断这个问题通知我们两次,我们可以经由单一的InterruptedException或单一的成功的Thread.interrupted()测试来得到这种通知。如果想要再次检查以了解是否被中断,则可以在调用Thread.interrupted()时将结果存储起来。接下来就是展示检查的惯用法,应该在run()方法中使用它来处理在中断状态被设置时,被阻塞和不被阻塞的各种可能,如:
          public void run(){
               try{
                    while(!Thread.interrupted()){
                             ....
                             try{
                                  //被阻塞的可能
                                  try{
                                       //不被阻塞的可能
                                  }finally{ ...cleanup();}
                             }finally{.....cleanup();}
                      }
                 }catch(InterruptedException e){}
          }
    这里的惯用法特别强调,在我们经由异常离开循环时,必须要正确的清理资源。被设计用来响应interrupt()的类必须建立一种策略,来确保它将保持一致的状态,这通常意味着所有需要清理的对象创建的操作的后面,都必须紧跟try-finally子句,从而使得无论run()循环如何退出,清理都会发生。

    转载于:https://www.cnblogs.com/wenjiang/archive/2012/08/28/2660549.html

    展开全文
  • 线程阻塞

    2015-10-22 15:49:00
    所谓的阻塞,就是线程能够运行,但是某个条件阻止它的运行,当线程处于阻塞状态时,调度器将忽略线程,不会分配给线程任何CPU时间,直到线程重新进入就绪状态,它才有可能执行操作。 为什么任务会进入阻塞的状态,...
  • 线程切换:线程处于可运行的状态,只是还没有获取CPU时间片,如yield方法 线程阻塞:线程请求资源等不满足,进入阻塞状态,无法运行 线程中断:操作系统中断是保存现场,进行中断处理。而Java线程中断仅仅是一个状态...
  • 关于线程阻塞的问题

    2016-05-20 16:36:36
    线程的阻塞状态:就是线程能够运行,但是某个条件阻止它的运行,当线程处于阻塞状态时,调度器将忽略线程,不会分配给线程任何CPU处理时间,直到线程重新进入就绪状态,它才有可能执行操作。 1.sleep方法可能导致...
  • 文章目录实例描述实现过程代码...当线程需要获得对象的内置锁,而该锁正被其他线程拥有时,线程处于阻塞状态当线程等待其他线程通知调度表可以运行时,该线程处于等待状态;当run()方法运行完毕或出现异常时,线...
  • 线程状态:   线程从创建、运行到结束总是处于下面五个状态之一:新建状态、就绪状态、运行状态、阻塞状态及死亡状态。... 一个线程处于新生状态时,程序还没有开始运行线程中的代码2.就绪状态(R...
  • 如何结束阻塞状态线程

    千次阅读 2011-05-31 07:52:00
    如何结束阻塞状态线程(会引起结束程序后进程还在) vc/mfc2009-02-07 16:30:26阅读109评论0 字号:大中小 订阅 如果一个线程由于等待某些事件的发生而被阻塞,又该如何实现该线程的中断呢?比如...
  • 1.睡眠状态一个线程执行代码的时候调用了sleep方法后,线程处于睡眠状态,需要设置一个睡眠时间,此时有其他线程需要执行时就会造成线程阻塞,而且sleep方法被调用之后,线程不会释放锁对象,也就是说锁还在该...
  • 查看线程的运行状态

    2019-07-04 11:19:00
    当线程需要获得对象的内置锁,而该锁正被别的线程拥有时,线程处于阻塞状态当线程等待其他线程通知调度表可以运行时,该线程处于等待状态。对于一些含有时间参数的方法,如thread的sleep()方法,可以...
  • sleep —— 让当前的正在执行的线程暂停指定的时间,并进入阻塞状态。在其睡眠的时间段内,该线程由于不是处于就绪状态,因此不会得到执行的机会。即使此时系统中没有任何其他可执行的线程,出于sleep()中的线程也...
  • 1、新建状态当线程被创建时,它短暂的处于这种状态。此时他已经分配了必要的资源并进行了初始化。 2、就绪状态:在这种状态下,只要调度器把时间 片分给线程,线程就可以运行。 3、运行状态:在这种状态下,线程...
  • 一个线程处于新建状态时,它仅仅是一个空的线程对象,系统不为它分配资源。 Thread t = new Thread(new Runner()); 2.就绪(Runnable) 程序通过线程对象调用启动方法start()后,系统会为这个...
  • 在生成线程对象,并没有调用该对象的start方法,这是线程处于创建状态。第二是就绪状态调用了线程对象的start方法之后,该线程就进入了就绪状态,但是此时线程调度程序还没有把该线程设置为当前线程,此时处于...
  • java多线程线程状态

    2016-08-21 19:40:14
    线程从创建、运行到结束总是处于下面五个状态之一:新建状态、就绪状态、运行状态、阻塞状态及死亡状态。... 一个线程处于新生状态时,程序还没有开始运行线程中的代码  2.就绪状态(Runnable)  
  • Java线程线程状态

    2017-08-04 14:47:17
    线程可以创建6状态: New()新创建、Runnable(可运行)、Blocked(被阻塞)、 Waiting(等待)、Timed waiting(计时等待)、...一个线程处于状态时,程序还没开始执行线程中的代码。在线程运行之前还有一些基础工
  • 线程阻塞的NodeJS

    千次阅读 2013-01-13 14:15:02
    好处是少了多线程的开销,发起IO操作后,不阻塞操作,做其他的事情,该线程一直处于忙碌状态(占用CPU),IO操作完成后,通知该线程(事件通知)。 缺点,编程模式复杂,在多核模式下无法利用更多的核。 ...
  • 清楚的理解和认知线程状态是java多线程的基础,多线程本质上其实就是管理多个线程的状态,以期在保证...4.java线程发生IO阻塞线程处于什么状态: 5.java线程和操作系统线程状态是如何对应的: java线程状态: ...
  • 线程状态

    2020-05-15 17:45:35
    当线程对象调用了start()方法之后,该线程就进入就绪状态。就绪状态线程处于就绪队列中,要等待JVM里线程调度器的调度。 运行状态: 如果就绪状态的线程获取 CPU 资源,就可以执行 run(),此时线程便处于运行状态...
  • 先观察下面这张图 线程从创建、运行到结束总是处于下面... 一个线程处于新生状态时,程序还没有开始运行线程中的代码 就绪状态 一个新创建的线程并不自动开始运行,要执行线程,必须调用线程的start()方法。...
  • 线程Thread的状态流转

    2018-02-08 12:41:06
    线程状态介绍线程的5种状态:新建(New)、就绪(Runnable)、运行(Running)、阻塞(Blocked)和死亡(Dead)5种... 就绪状态当线程对象调用了start()方法之后,该线程处于就绪Runnable状态。Java虚拟机会为其创建方法...
  • 线程有哪些状态

    2020-05-29 16:25:48
    在生成线程对象,并没有调用该对象的start方法,这是线程处于创建状态。 就绪状态调用了线程对象的start方法之后,该线程就进入了就绪状态,但是此时线程调度程序还没有把该线程设置为当前线程,此时处于就绪...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,730
精华内容 692
关键字:

当线程处于阻塞状态线程