线程的状态

线程的状态

线程五大状态

1. 创建状态：使用Thread t = new Thread()创建一个新的线程
2. 就绪状态：当调用start()方法，线程立即进入就绪状态，但不意味着立即调度运行，需要等待cpu的调度
3. 运行状态：线程在运行状态时才
   真正执行线程体的代码块
4. 阻塞状态：线程在运行状态时，调用sleep，wait或同步锁定时，线程进入阻塞状态，代码不继续往下执行，需要等到阻塞状态解除后，重新进入就绪状态
5. 死亡状态：线程被干涉中断或者自然执行结束，就会进入死亡状态。一旦进入死亡状态，就不能再次启动
   

线程中断

中断线程可以使用一个标志位进行控制，比如当flag = false时，终止线程运行，代码如下。不推荐使用JDK提供的stop()、destroy()方法。

public class TestStop implements Runnable{
    private boolean flag = true;
    private int i = 0;

    @Override
    public void run() {
        while (this.flag){
            System.out.println("线程正在执行..." + i++);
        }
    }

    public void stop(){
        this.flag = false;
    }

    public static void main(String[] args) {
        TestStop testStop = new TestStop();
        new Thread(testStop).start();

        try{
            Thread.sleep(3000); // 主线程休眠3秒后，让副线程中断
        }catch (InterruptedException e){
            e.printStackTrace();
        }

        testStop.stop();
    }
}

线程休眠

1. 通过Thread.sleep(time)控制当前线程阻塞的毫秒数，比如time=1000，表示阻塞1秒。
2. 调用sleep()会存在异常InterruptedException，需要捕获或者抛出。
3. sleep时间结束后线程进入就绪状态
4. 使用sleep可以模拟网络延时，倒计时等
5. 注意，每一个对象都有一把锁，线程进入sleep并不会释放锁

下面通过sleep()模拟一个时钟：

import java.text.SimpleDateFormat;
import java.util.Date;

public class TestSleep {
    public static void main(String[] args) {
        Date currentTime;
        while(true){
            try{
                currentTime = new Date(System.currentTimeMillis());
                System.out.println(new SimpleDateFormat("HH:mm:ss").format(currentTime));
                Thread.sleep(1000);
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

线程礼让

使用yield方法让当前正在执行的线程暂停，但不阻塞，将线程从运行状态装维就绪状态，让cpu重新调度，礼让不一定成功，主要看cpu的调度。

public class TestYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield, "a").start();
        new Thread(myYield, "b").start();
    }
}


class MyYield implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "开始执行！");
        Thread.yield();
        System.out.println(Thread.currentThread().getName() + "结束执行！");
    }
}

/**
 * 输出:
 * a开始执行！
 * b开始执行！
 * a结束执行！
 * b结束执行！
 */

观测线程的状态

Thread.State是一个枚举类，包含以下六种状态：

• NEW：尚未启动的线程处于此状态
• RUNNABLE：在Java虚拟机中执行的线程处于此状态
• BLOCKED：被阻塞等待监视器锁定的线程处于此状态
• WAITING：正在等在另一个线程执行特定动作的线程处于此状态
• TIMED_WAITING：正在等待另一个线程执行动作达到指定等待时间的线程处于此状态
• TERMINATED：已退出的先储层处于此状态

一个线程可以在给定时间点处于一个状态，这些状态不反映任何操作系统线程状态的虚拟机状态

可通过new Thread().getState()来获取线程的当前状态

线程优先级

Java提供一个线程调度器来监控程序中启动后进入就绪状态的所有线程，并按照优先级决定先调度哪个线程来执行

现成的优先级用数字表示，范围从1~10，从低到高，Java用枚举量提供了三个常见的优先级：

• Thread.MIN_PRIORITY = 1
• Thread.MAX_PRIORITY = 10;
• Thread.NORM_PRIORITY = 5;

获取优先级和设置优先级的方法：

• getPriority()
• setPriority(int)

优先级的设定建议在start()调度前。

public class TestPriority {
    public static void main(String[] args) {

        // 打印主线程优先级  5
        System.out.println(Thread.currentThread().getName() + "的优先级---->" + Thread.currentThread().getPriority() );

        MyPriority myPriority = new MyPriority();

        Thread t1 = new Thread(myPriority, "t1");
        Thread t2 = new Thread(myPriority, "t2");
        Thread t3 = new Thread(myPriority, "t3");
        Thread t4 = new Thread(myPriority, "t4");
        Thread t5 = new Thread(myPriority, "t5");

        // 设置线程优先级
        t1.setPriority(1);
        t1.start();

        t2.setPriority(4);
        t2.start();

        t3.setPriority(Thread.NORM_PRIORITY);
        t3.start();

        t4.setPriority(10);
        t4.start();

        t5.setPriority(4);
        t5.start();
    }


}


class MyPriority implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "的优先级---->" + Thread.currentThread().getPriority() );
    }
}

/**
 * 输出：
 * main的优先级---->5
 * t4的优先级---->10
 * t3的优先级---->5
 * t2的优先级---->4
 * t1的优先级---->1
 * t5的优先级---->4
 */

优先级低指示意味着获得调度的概率低，并不是优先级低就不会被调用。优先级高也不一定先被调用，和cpu的心情有关。

守护线程

在Java中有两类线程，一种是用户线程，另一种是守护线程。平常创建使用的都是用户线程。

守护线程相当于用户线程的“保姆”，用来为其他用户线程提供守护(服务)，垃圾回收器(GC)是最典型的守护线程例子。

当最后一个用户线程结束时，守护线程会随着虚拟机一同结束。当所有用户线程都结束后，只剩下守护线程，虚拟机会退出，因为没有了被守护者，守护线程也就没有工作可做，也就没有继续运行程序的必要。

可通过new Thread().setDaemon(true)将一个线程设置为守护线程，默认参数为false。