第16章-多线程 --- 线程的生命周期

浏览数：22 / 时间：2015年06月08日

线程生命周期

　　线程在生命周期中要经历5中状态: 新建(New)、就绪(Runnable)、运行(Running)、阻塞(Blocked)和死亡(Dead).

　　当线程被创建并启动以后，它既不是一启动就进入执行状态，也不是一直处于执行状态.

　　当线程启动以后，它不可能一直"霸占"这CPU独自运行,所以CPU需要在多条线程之间切换,于是线程状态也会多次在运行、阻塞之间切换.

新建和就绪状态

　　当程序使用new关键字创建了一个线程之后,该线程就处于新建状态,此时它和其他的Java对象一样,仅仅由Java虚拟机为其分配内存,此时它和其他的Java对象一样,仅仅由Java虚拟机为其分配内存,并初始化其成员变量的值。此时的线程对象没有表现出任何线程的动态特征,程序也不会执行线程的线程执行体。

　　当线程对象调用了start()方法之后,该线程处于就绪状态,Java虚拟机会为其创建方法调用栈和程序计数器,处理这个状态中的线程并没有开始运行,只是表示该线程可以运行了,至于该线程何时才开始运行,取决于JVM里线程调度器的调度。

　　（注意:

　　　　　　启动线程使用start()方法,而不是run()方法! 永远不要调用线程对象的run()方法！

　　　　　　调用start()方法来启动线程,系统会把该run()方法当成线程执行体来处理.

　　　　　　如果是直接调用线程对象的run()方法,则run()方法立即就会被执行,而且在run()方法返回之前其他线程无法并发执行---也就是说,系统把线程对象当成一个普通对象,而run()方法也是一个普通方法,而不是线程执行体。　

　　）

下面举例说明--直接调用run()方法

public class InvokeRun extends Thread
{
    private int i;
    
    //重写run()方法,run()方法的方法体就是线程执行体
    @Override
    public void run()
    {
        for(int i = 0;i < 100;i++)
        {
            //直接调用run()方法时,Thread的this.getName()返回的是该对象的名字
            //而不是当前线程的名字
            //使用Thread.currentThread().getName()总是获取当前线程的名字
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }
    
    public static void main(String[] args)
    {
        for(int i = 0;i < 100;i++)
        {
            //调用Thread的currentThread()方法获取当前线程
            System.out.println(Thread.currentThread().getName() + " " + i);
            
            if(i == 20)
            {
                //直接调用线程对象的run()方法
                //系统会把线程对象当前普通对象,把run()方法当成普通方法
                //所以下面两行代码并不会启动两个线程,而是以此执行两个run()方法
                new InvokeRun().run();
                
                new InvokeRun().run();
            }
        }
    }
}

运行和阻塞状态

　　如果处于就绪状态的线程获得了CPU,开始执行run()方法的线程执行体,则该线程处于运行状态.

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

　　1.线程调用sleep()方法主动放弃所占用的处理器资源.

　　2.线程调用了一个阻塞式的IO方法,在该方法返回之前,该线程被阻塞

　　3.线程试图获得一个同步监视器,但该监视器正被其他线程所持有.

　　4.线程在等待某个通知(notify).

　　5.程序调用了线程的suspend()方法将该线程挂起,但这个方法容易导致死锁,所以应该尽量避免使用该方法.

　　当前正在执行的线程被阻塞之后,其他线程就可以获得执行机会。被阻塞的线程会在合适的时候重新进入就绪状态,注意是就绪状态而不是运行状态。也就是说,被阻塞线程的阻塞解决后,必须重新等待线程调用器再次调度它.

　　当发生如下情况时可以解决上面的阻塞,让线程重新进入就绪状态:

　　1.调用sleep()方法的线程经过了指定时间.

　　2.线程调用的阻塞式IO方法已经返回.

　　3.线程成功地获得了试图取得的同步监视器.

　　4.线程正在等待某个通知时,其他线程发出了一个通知.

　　5.处于挂起状态的线程被调用了resume()恢复方法

下图显示了线程的状态转换图:

　　上图显示了：

　　　　线程从阻塞状态只能进入就绪状态,无法直接进入运行状态.

　　　　就绪状态和运行状态之间的转换通常不受程序控制,而是由系统线程调度所决定,当处于就绪状态的线程获得处理器资源时,该线程进入运行状态.

　　　　当处于运行状态的线程失去处理器资源时,该线程进入就绪状态.

　　　　(注意: yield()方法 --- 调用yield()方法可以让运行状态的线程转入就绪状态)

线程死亡

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

　　1.run()或call()方法执行完成,线程正常结束.

　　2.线程抛出一个未捕获的Exception或Error.

　　3.直接调用该线程的stop()方法来结束该信息--该方法容易导致死锁,通常不推荐使用.　　

　　(注意:当主线程结束时,其他线程不受任何影响,并不会随之结束.一旦子线程启动起来后,它就拥有和主线程相同的地位,它不会受主线程的影响。)

　　可以调用线程对象的isAlive()方法来检查某个线程是否已经死亡,当线程处于就绪、运行、阻塞3种状态时，该方法将返回true;当线程处于新建、死亡状态时，该方法将返回false.

　　(注意:不要试图对一个已经死亡的线程调用start()方法使它重新启动,死亡就是死亡,该线程将不可再次作为线程执行.)

下面程序举例:对已经死亡的线程调用start()方法

public class StartDead extends Thread
{
    private int i;
    
    //重写run()方法,run()方法的方法体就是线程执行体
    public void run()
    {
        for(;i < 100;i++)
        {
            System.out.println(getName() + "  " + i);
        }
    }
    
    public static void main(String[] args)
    {
        //创建线程对象
        StartDead sd = new StartDead();
        
        for(int i = 0;i < 300;i++)
        {
            //调用Thread的currentThread()方法获取当前线程
            System.out.println(Thread.currentThread().getName() + "  " + i);
            
            if(i == 20)
            {
                //启动线程
                sd.start();
                
                //判断启动后的线程的isAlive()值,输出true
                System.out.println("-------------sd.isAlive:"+sd.isAlive());
            }
            
            //当线程处于新建、死亡两种状态时,isAlive()方法返回false
            //当i > 20时,该线程肯定已经启动过了,如果sd.isAlive为假时
            //那就是死亡状态了
            
            if(i > 20 && !sd.isAlive())
            {
                //试图再次启动该线程
                sd.start();
            }
        }
    }
}