线程的五种状态及改变状态的三种方法

 

　　1、新状态：线程对象已经创建，还没有在其上调用start()方法。

　　2、可运行状态：当线程有资格运行，但调度程序还没有把它选定为运行线程时线程所处的状态。当start()方法调用时，线程首先进入可运行状态。在线程运行之后或者从阻塞、等待或睡眠状态回来后，也返回到可运行状态。

　　3、运行状态：线程调度程序从可运行池中选择一个线程作为当前线程时线程所处的状态。这也是线程进入运行状态的唯一一种方式。

　　4、等待/阻塞/睡眠状态：这是线程有资格运行时它所处的状态。实际上这个三状态组合为一种，其共同点是：线程仍旧是活的，但是当前没有条件运行。换句话说，它是可运行的，但是如果某件事件出现，他可能返回到可运行状态。

　　5、死亡态：当线程的run()方法完成时就认为它死去。这个线程对象也许是活的，但是，它已经不是一个单独执行的线程。线程一旦死亡，就不能复生。如果在一个死去的线程上调用start()方法，会抛出java.lang.IllegalThreadStateException异常。

 

　　1、睡眠

　　Thread.sleep(long millis)和Thread.sleep(long millis, int nanos)静态方法强制当前正在执行的线程休眠（暂停执行），以“减慢线程”。当线程睡眠时，它入睡在某个地方，在苏醒之前不会返回到可运行状态。当睡眠时间到期，则返回到可运行状态。

　　线程睡眠的原因：线程执行太快，或者需要强制进入下一轮，因为Java规范不保证合理的轮换。

package thread;

public class MulityT implements Runnable {
    private String s;
    private long i = 1;

    public MulityT(String s) {
        this.s = s;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        while (i < 10) {
            System.out.println(s + "=====" + i++);
//            Thread.yield();
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MulityT m = new MulityT("a");
        Thread t = new Thread(m);
        t.start();
        MulityT m2 = new MulityT("b");
        Thread t2 = new Thread(m2);
        t2.start();
        MulityT m3 = new MulityT("c");
        Thread t3 = new Thread(m3);
        t3.start();
        
    }

}

　　输出结果:(每轮输出后暂停一秒左右)

a=====1
b=====1
c=====1
b=====2
a=====2
c=====2
c=====3
a=====3
b=====3
a=====4
c=====4
b=====4
a=====5
c=====5
b=====5
a=====6
c=====6
b=====6
b=====7
a=====7
c=====7
b=====8
a=====8
c=====8
c=====9
a=====9
b=====9

　　1、线程睡眠是帮助所有线程获得运行机会的最好方法。

　　2、线程睡眠到期自动苏醒，并返回到可运行状态，不是运行状态。sleep()中指定的时间是线程不会运行的最短时间。因此，sleep()方法不能保证该线程睡眠到期后就开始执行。

　　3、sleep()是静态方法，只能控制当前正在运行的线程。

 

　　2、线程的优先级和线程让步yield()

　　线程的让步是通过Thread.yield()来实现的。yield()方法的作用是：暂停当前正在执行的线程对象，并执行其他线程。

 　　要理解yield()，必须了解线程的优先级的概念。线程总是存在优先级，优先级范围在1~10之间。JVM线程调度程序是基于优先级的抢先调度机制。在大多数情况下，当前运行的线程优先级将大于或等于线程池中任何线程的优先级。但这仅仅是大多数情况。

 　　注意：当设计多线程应用程序的时候，一定不要依赖于线程的优先级。因为线程调度优先级操作是没有保障的，只能把线程优先级作用作为一种提高程序效率的方法，但是要保证程序不依赖这种操作。 

　　当线程池中线程都具有相同的优先级，调度程序的JVM实现自由选择它喜欢的线程。这时候调度程序的操作有两种可能：一是选择一个线程运行，直到它阻塞或者运行完成为止。二是时间分片，为池内的每个线程提供均等的运行机会。

　　Thread.yield()方法作用是：暂停当前正在执行的线程对象，并执行其他线程。

　　yield()应该做的是让当前运行线程回到可运行状态，以允许具有相同优先级的其他线程获得运行机会。因此，使用yield()的目的是让相同优先级的线程之间能适当的轮转执行。但是，实际中无法保证yield()达到让步目的，因为让步的线程还有可能被线程调度程序再次选中。

package thread;

public class MulityT implements Runnable {
    private String s;
    private long i = 1;

    public MulityT(String s) {
        this.s = s;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        while (i < 10) {
            System.out.println(s + "=====" + i++);
            Thread.yield();
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MulityT m = new MulityT("a");
        Thread t = new Thread(m);
        t.start();
        MulityT m2 = new MulityT("b");
        Thread t2 = new Thread(m2);
        t2.start();
        MulityT m3 = new MulityT("c");
        Thread t3 = new Thread(m3);
        t3.start();
        
    }

}

　　输出结果:

a=====1
c=====1
b=====1
c=====2
a=====2
b=====2
c=====3
a=====3
b=====3
c=====4
a=====4
b=====4
c=====5
a=====5
b=====5
c=====6
a=====6
b=====6
c=====7
b=====7
a=====7
c=====8
b=====8
c=====9
a=====8
b=====9
a=====9

　　结论：yield()从未导致线程转到等待/睡眠/阻塞状态。在大多数情况下，yield()将导致线程从运行状态转到可运行状态，但有可能没有效果。

 

　　3、join()方法

 　　Thread的非静态方法join()让一个线程B“加入”到另外一个线程A的尾部。在A执行完毕之前，B不能工作。

　　另外，join()方法还有带超时限制的重载版本。例如t.join(5000);则让线程等待5000毫秒，如果超过这个时间，则停止等待，变为可运行状态。

 

package thread;

public class MulityT implements Runnable {
    private String s;
    private long i = 1;

    public MulityT(String s) {
        this.s = s;
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        while (i < 10) {
            System.out.println(s + "=====" + i++);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MulityT m = new MulityT("a");
        Thread t = new Thread(m);
        t.start();
        MulityT m2 = new MulityT("b");
        Thread t2 = new Thread(m2);
        t2.start();
        t2.join();
        MulityT m3 = new MulityT("c");
        Thread t3 = new Thread(m3);
        t3.start();
        
    }

}

　　输出结果:

a=====1
b=====1
a=====2
b=====2
a=====3
b=====3
a=====4
a=====5
b=====4
a=====6
b=====5
a=====7
b=====6
a=====8
b=====7
a=====9
b=====8
b=====9
c=====1
c=====2
c=====3
c=====4
c=====5
c=====6
c=====7
c=====8
c=====9

　　小结:

　　到目前位置，介绍了线程离开运行状态的3种方法：

　　1、调用Thread.sleep()：使当前线程睡眠至少多少毫秒（尽管它可能在指定的时间之前被中断）。

　　2、调用Thread.yield()：不能保障太多事情，尽管通常它会让当前运行线程回到可运行性状态，使得有相同优先级的线程有机会执行。

　　3、调用join()方法：保证当前线程停止执行，直到该线程所加入的线程完成为止。然而，如果它加入的线程没有存活，则当前线程不需要停止。