Java多线程——Java中的进程状态

线程状态

一个线程对象在它的生命周期内，需要经历5个状态

---

• 新生状态（New）

  ​ 用new关键字建立一个线程对象后，该线程对象就处于新生状态。处于新生状态的线程有自己的内存控件，通过调用start方法进入就绪状态

• 就绪状态（Runnable）

  ​ 处于就绪状态的线程已经具备了运行条件，但是还没有分配到CPU，处于“线程就绪队列”，等待系统为其分配CPU。就绪状态并不是执行状态，当系统选定一个等待执行的Thread对象后，它就会进入执行状态，一旦获得CPU，线程就进入运行状态并自动调用自己的run方法。有4种原因会导致线程进入就绪状态：

  • 新建线程：调用start()方法，进入就绪状态。
  • 阻塞线程：阻塞解除，进入就绪状态。
  • 运行线程：调用yield()方法，直接进入就绪状态。
  • 运行线程：JVM将CPU资源从本地线程切换到其他线程。

• 运行状态（Running）

  ​ 在运行状态的线程执行自己的run方法中的代码，直接调用其他方法而终止或等待某资源而阻塞或完成任务而死亡。如果在给定的时间片内没有执行结束，就会被系统给换下来回到就绪状态。也可能由于某些“导致阻塞的事件”而进入阻塞状态。

• 阻塞状态（Blocked）

  ​ 阻塞指的是暂停一个线程的执行以等待某个条件发生（如某资源就绪）。有4种原因会导致阻塞：

  • 执行sleep(int millsecond)方法，使当前线程休眠，进入阻塞状态。当指定的时间到了后，线程进入就绪状态。
  • 执行wait()方法，使当前线程进入阻塞状态。当使用nofity()方法唤醒这个线程后，它进入就绪状态。
  • 线程运行时，某个操作进入阻塞状态，比如执行IO流操作（read()/write()方法本身就是阻塞的方法）。只有当引起该操作阻塞的原因消失后，线程进入就绪状态。
  • join()线程联合：当某个线程等待另一个线程执行结束后，才能继续执行时，使用join()方法。

• 死亡状态（Terminated）

  ​ 死亡状态是线程生命周期中的最后一个阶段。线程死亡的原因有两个。

  • 正常运行的线程完成了它run()方法内的全部工作。
  • 线程被强制终止。（如通过执行stop()或destroy()方法来终止一个线程（注：stop()或destroy()方法已经被JDK废弃，不推荐使用）。）

终止线程的典型方式

​ 终止线程我们一般不使用JDK提供的stop()或destroy()方法（它们本身也被JDK废弃了）。通常的做法是提供一个boolean型的终止变量，将这个变量置为false时，则终止线程的运行。

例子一：终止线程的典型方法（重要）

package com.shenqi.stopthread;

public class TestThreadTerminate implements Runnable {

    String name;

    //标记变量，表示线程是否可中止。
    boolean live = true;

    public TestThreadTerminate(String name) {
        super();
        this.name = name;
    }

    @Override
    public void run() {
        int i = 0;
        //当live的值是true时，继续线程体；false则结束循环，继而终止线程体。
        while(live){
            System.out.println(name + (i++));
        }
    }

    public void terminate(){
        live = false;
    }

    public static void main(String[] args) {
        TestThreadTerminate threadState = new TestThreadTerminate("线程A");
        //新生状态
        Thread thread = new Thread(threadState);
        //就绪状态
        thread.start();
        for (int i = 0; i < 100; i++) {
            System.out.println("主线程：" + i);
        }
        //在terminate()方法中将live设置为false，终止线程。
        threadState.terminate();
        System.out.println("threadState is stop!");
    }

}

程序运行结果：

主线程：0
主线程：1
主线程：2
主线程：3
主线程：4
主线程：5
主线程：6
线程A0
主线程：7
主线程：8
主线程：9
主线程：10
主线程：11
主线程：12
主线程：13
主线程：14
主线程：15
主线程：16
主线程：17
主线程：18
主线程：19
主线程：20
主线程：21
主线程：22
主线程：23
主线程：24
主线程：25
主线程：26
主线程：27
主线程：28
主线程：29
主线程：30
主线程：31
主线程：32
线程A1
主线程：33
线程A2
主线程：34
线程A3
线程A4
主线程：35
线程A5
主线程：36
主线程：37
主线程：38
主线程：39
主线程：40
主线程：41
线程A6
主线程：42
主线程：43
主线程：44
主线程：45
主线程：46
主线程：47
主线程：48
主线程：49
主线程：50
主线程：51
主线程：52
主线程：53
线程A7
主线程：54
线程A8
主线程：55
线程A9
主线程：56
线程A10
主线程：57
线程A11
线程A12
线程A13
线程A14
线程A15
线程A16
线程A17
线程A18
线程A19
线程A20
线程A21
线程A22
线程A23
主线程：58
线程A24
主线程：59
主线程：60
主线程：61
主线程：62
主线程：63
主线程：64
主线程：65
主线程：66
主线程：67
主线程：68
主线程：69
主线程：70
主线程：71
主线程：72
主线程：73
主线程：74
主线程：75
主线程：76
主线程：77
主线程：78
线程A25
主线程：79
线程A26
主线程：80
主线程：81
线程A27
主线程：82
主线程：83
主线程：84
主线程：85
线程A28
主线程：86
线程A29
主线程：87
线程A30
主线程：88
线程A31
主线程：89
线程A32
线程A33
线程A34
主线程：90
线程A35
主线程：91
线程A36
主线程：92
主线程：93
主线程：94
线程A37
主线程：95
线程A38
主线程：96
主线程：97
主线程：98
主线程：99
线程A39
threadState is stop!

暂停线程执行sleep/yield

暂停线程执行常用的方法有sleep()和yield()方法，这两个方法的区别是：

• sleep()方法：可以让正在运行的线程进入阻塞状态，直到休眠时间满了，进入就绪状态。
• yield()方法：可以让正在运行的线程直接进入就绪状态，让出CPU的使用权。

例子二：暂停线程的典型方法——sleep()

package com.shenqi.sleepthread;

public class TestThreadSleep {

    public static void main(String[] args) {
        SleepThreadState thread1 = new SleepThreadState();
        thread1.start();
        SleepThreadState thread2 = new SleepThreadState();
        thread2.start();
    }

}

//使用继承方法实现多线程
class SleepThreadState extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(this.getName() + ":" + i);
            try {
                //调用线程的sleep()方法
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }
        }
    }
}

执行结果如下所示：（注：使用sleep()方法运行时可以感受到每条结果输出之前的延迟。）

Thread-1:0
Thread-0:0
Thread-1:1
Thread-0:1
Thread-0:2
Thread-1:2
Thread-1:3
Thread-0:3
Thread-1:4
Thread-0:4

例子二：暂停线程的典型方法——yield()

package com.shenqi.yieldthread;

public class TestThreadYield {

    public static void main(String[] args) {
        StateThreadYield thread1 = new StateThreadYield();
        thread1.start();
        StateThreadYield thread2 = new StateThreadYield();
        thread2.start();
    }

}

//使用继承方式实现多线程
class StateThreadYield extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(this.getName() + ":" + i);
            //调用线程的yield()方法
            Thread.yield();
        }
    }
}

运行结果如下所示：（注：yield()方法可以引起线程切换，但运行时没有明显延迟。）

Thread-0:0
Thread-0:1
Thread-0:2
Thread-0:3
Thread-0:4
Thread-1:0
Thread-1:1
Thread-1:2
Thread-1:3
Thread-1:4
Thread-1:5
Thread-0:5
Thread-1:6
Thread-0:6
Thread-0:7
Thread-1:7
Thread-1:8
Thread-0:8
Thread-0:9
Thread-1:9