Java之线程的五大状态

new线程对象进入新生状态，调用start线程进入就绪状态，线程被调度进入运行状态此时若线程中断或结束则进入死亡状态，若调用sleep或wait或同步锁定时，线程进入阻塞状态并等待cpu调度。

• 线程的停止

建议进程自行停止，若真要手动停止就设置标志位，不建议使用stop、destroy等JDK淘汰的方法

以下为设置标志位方法:

package 线程五大状态;
//测试停止线程
//1.建议线程正常停止---->利用次数，不建议死循环
//2.建议使用标志位---->设置一个标志位
//3.不要使用stop()或者destroy()等过时或者JDK不建议使用的方法
public class TestStop implements Runnable{
    //1.设置一个标志位
    private boolean flag = true;
    @Override
    public void run() {
        int i = 0;
        while(this.flag){
            System.out.println("run...Thread" + i++);
        }
    }
    //2.设置一个公开的方法停止线程，转换标志位
    public void stop(){
        this.flag = false;
    }
    public static void main(String[] args) {
        TestStop t = new TestStop();
        new Thread(t).start();
        for (int i = 0; i < 1000; i++) {
            System.out.println("main" + i);
            if(i == 900){
                //调用stop方法切换标志位，停止线程
                t.stop();
                System.out.println("线程该停止了");
            }
        }
    }
}

 结果为当i为900时只执行后者程序，前者停止。

• 线程的休眠

 sleep(*)方法，*的单位为毫秒1000ms = 1s，一般要休眠一秒就* = 1000即可。

sleep()存在异常InterruptedExcpetion，需要抛出。

sleep()时间达到后线程进入就绪状态。

sleep()可以模拟网络延时，倒计时等。

每个对象都有一个锁，sleep不会释放锁。

package 线程五大状态;
//模拟网络延时
public class TestSleep implements Runnable{
    private int tickets = 10;
    @Override
    public void run() {
        while(true){
            if(tickets<=0){
                break;
            }
            //模拟延时:放大问题的发生性
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println(Thread.currentThread().getName() + "拿了第" + tickets-- + "张票");//注意不可以将tickets--单独写出，容易发生数据重复
        }
    }

    public static void main(String[] args) {
        TestSleep testSleep = new TestSleep();
        new Thread(testSleep, "小明").start();
        new Thread(testSleep, "老师").start();
        new Thread(testSleep, "黄牛党").start();
    }
}

模拟倒计时:

package 线程五大状态;
//模拟倒计时
public class TestSleep2 {
    public void tenDown(){
        int num = 10;
        while(true){
            try {
                Thread.sleep(1000);
                System.out.println(num--);
                if(num<=0){
                    break;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    public static void main(String[] args) {
        TestSleep2 testSleep2 = new TestSleep2();
        testSleep2.tenDown();
    }
}

• 线程的礼让

 yield，让当前正在执行的线程暂停，但不阻塞

将线程从运行态转为就绪态

让cpu重新调度，礼让不一定成功，看cpu心情

package 线程五大状态;
//测试礼让线程
//礼让不一定成功看cpu心情
public class TestYield {
    public static void main(String[] args) {
        MyYield myYield = new MyYield();
        new Thread(myYield, "线程1").start();
        new Thread(myYield, "线程2").start();
    }
}
class MyYield implements Runnable{
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + "线程开始执行");
        Thread.yield();//礼让方法
        System.out.println(Thread.currentThread().getName() + "线程停止执行");
    }
}
/*礼让成功
线程2线程开始执行
线程1线程开始执行
线程1线程停止执行
线程2线程停止执行*/
/*礼让失败
线程1线程开始执行
线程1线程停止执行
线程2线程开始执行
线程2线程停止执行*/

• 线程强制执行

Join合并线程，待此线程执行完成后，再执行其他线程

类似于插队

package 线程五大状态;
//测试join方法，想象成插队
public class TestJoin implements Runnable{
    @Override
    public void run() {
        for (int i = 0; i < 1000; i++) {
            System.out.println("线程a:" + i);
        }
    }

    public static void main(String[] args) {
        TestJoin testJoin = new TestJoin();
        Thread thread = new Thread(testJoin);
        thread.start();
        //主线程
        for (int i = 0; i < 1000; i++) {
            System.out.println("线程b:" + i);
            if(i==200){//只要线程b次数为200时，就优先将a线程的剩余全部执行结束，再执行b线程
                try {
                    System.out.println("全部执行a");
                    thread.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

• 观测线程状态

注意:死亡后的线程不能再次启动了 

package 线程五大状态;
//观察测试线程的状态
public class TestState {
    public static void main(String[] args) throws Exception{
        Thread thread = new Thread(()-> {
            for (int i = 0; i < 5; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("//");
        });
        //观察状态
        Thread.State state = thread.getState();
        System.out.println(state);//NEW
        //观察启动后
        thread.start();//启动线程
        state = thread.getState();
        System.out.println(state);
        while(state!=Thread.State.TERMINATED){//只要线程不终止，就一直输出状态
            Thread.sleep(100);//因为延时了所以状态为TIMED_WAITING
            state = thread.getState();//更新线程状态
            System.out.println(state);//输出状态
        }
    }
}
/*NEW
RUNNABLE
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
TIMED_WAITING
//
TERMINATED*/