Java多线程之线程5种状态

1、五个状态

2、方法

3、停止线程

• 不推荐使用stop（） 和destroy（）方法
• 推荐线程自己停止下来
• 建议使用一个标志位进行终止变量
  • flag == false

public class MyThreadSeven implements Runnable {
    //设置标志位
    private boolean flag = true;

    @Override
    public void run() {
        int i = 0;
        while (flag) {
            System.out.println("run..." + i++);
        }
    }
    //定义stop（）方法
    public void stop() {
        this.flag = false;
    }

    public static void main(String[] args) {
        
        MyThreadSeven myThreadSeven = new MyThreadSeven();
        new Thread(myThreadSeven).start();
        
        for (int i = 0; i < 20; i++) {
            
            System.out.println("main...."+i);
            
            if (i == 15) {
                myThreadSeven.stop();
                System.out.println("线程停止了");
            }
        }
    }
}

4、线程的休眠

• sleep 存在异常
• sleep是时间达到后，线程进入就绪状态
• sleep可以模拟网络延时，倒计时等
  • 放大事情的发生性
• 每个对象都有一个锁，sleep不会释放锁

public class MyThreadSleep {
    //倒计时
    public static  void down(int sec) {
        while(true){
            System.out.println(sec--);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            if (sec==0){
                break;
            }
        }
    }
    //网络延时
    public static void delay(){
        //获取当前时间
        Date startTime = new Date(System.currentTimeMillis());
        while (true){
            //格式工厂
            System.out.println(new SimpleDateFormat("yyyy-mm-dd HH:mm:ss").format(startTime));
            //一秒延时
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            //更新时间戳
            startTime = new Date(System.currentTimeMillis());
        }
    }


    public static void main(String[] args) {
        // delay();
        down(10);
    }

龟兔赛跑例子

public class MyThreadFive implements Runnable {
    //胜利者
    private  static String WIN;
    @Override
    public void run() {

        for (int i = 1; i <=100; i++) {
            //兔子睡觉
            if(Thread.currentThread().getName().equals("兔子") && i%10==0){
                try {
                    Thread.sleep(2);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            if(getOver(i)){
                break;
            }
            System.out.println(Thread.currentThread().getName()+"跑了"+i+"步");
        }

    }
    //判断比赛是否结束。
    public boolean getOver(int step){
        if (WIN!=null){
            return true;
        }
        if(step==100){
            WIN = Thread.currentThread().getName();
            System.out.println(WIN+"赢了比赛");
            return true;
        }
        return false;
    }

    public static void main(String[] args) {
        MyThreadFive myThreadFive = new MyThreadFive();
        new Thread(myThreadFive,"兔子").start();
        new Thread(myThreadFive,"乌龟").start();
    }
}

5、线程的强制执行

public class MyThreadEight implements Runnable {

    @Override
    public void run() {

        for (int i = 0; i <100 ; i++) {
            try {
                Thread.sleep(10);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("插队"+i);
        }
    }

    public static void main(String[] args) throws InterruptedException {
        MyThreadEight myThreadEight = new MyThreadEight();
        Thread thread = new Thread(myThreadEight);
        thread.start();

        for (int i = 0; i <50 ; i++) {
            Thread.sleep(10);
            if (i==20){
                thread.join();
            }
            System.out.println("mian...."+i);
        }
    }
}

6、线程的状态

NEW, RUNNABLE, WAITING, TIMED_WAITING, TERMINATED;

public class MyThreadNine {


    public static void main(String[] args) {
        Thread thread = new Thread(()->{
            for (int i = 0; i < 3; i++) {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            System.out.println("========");
        });

        //观察状态
        Thread.State state = thread.getState();
        System.out.println(state);

        //观察启动后的
        thread.start();
        state = thread.getState();
        //持续观察
        while (state!=Thread.State.TERMINATED){
            System.out.println(state);
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            state = thread.getState();
        }
        System.out.