Day38

线程状态

新生状态----->就绪状态------>运行状态------>(1)死亡状态，不能重新开启(2)堵塞状态----->返回就绪状态

new Thread；线程对象就进入到了新生状态，每个线程有自己的内存空间(工作空间)，工作空间与主内存交互，一旦调用了start()方法就进入了就绪状态具备了运行的能力和条件，进入就绪状态不代表立马被调度，要等待cpu的调度

进入就绪状态的四种原因：(1)start()方法被调用(2)进入堵塞状态，堵塞解除(3)yield方法，避免线程占用过多，中断一下，重新进入就绪(4)jvm本身将cpu从本地线程切换到其他线程

运行状态是就绪状态被cpu调度才能进入运行状态，进入就绪状态，线程才真正执行线程体的代码块。

进入堵塞状态的四种原因：(1)sleep 延迟，抱着资源等待(2)wait 站在一边，自己不用，资源别人可以拿去用(3)join插入，等别人运行完(4)read，write等通过操作系统调度

进入死忙状态的原因：(1)线程体的代码执行完毕(2)被强行终止

终止线程

• 1、线程正常执行—>次数
• 2、外部干涉---->加入标识
• 不要使用stop destryo

package com.sxt.state;

/**
 * 终止线程
 * 1、线程正常执行--->次数
 * 2、外部干涉---->加入标识
 * 不要使用stop destryo
 */
public class TerminateTread implements Runnable{
    //1、加入标识线程体是否可以运行
    private boolean flag=true;
    private String name;

    public TerminateTread(String name) {
        this.name = name;
    }

    @Override
    public void run() {
        //2、加入标识  true--->运行 false---->停止
        int i=0;
        while (flag){
            System.out.println("线程---->"+i++);
        }
    }
    //3、对外提供方法改变标识
    public void terminate(){
        this.flag=false;
    }

    public static void main(String[] args) {
        TerminateTread tt=new TerminateTread("C罗");
        new Thread(tt).start();

        for (int i = 0; i <99 ; i++) {
            if (i==88) {
                tt.terminate();//线程的终止
                System.out.println("game over");
            }
            System.out.println("main--->"+i);
        }
    }
}

Sleep

sleep(时间)指定当前线程阻塞的毫秒数

sleep存在异常InterruptedException

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

sleep可以模拟网络延迟、倒计时等

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

package com.sxt.state;
/**
 * sleep模仿网络延时，放大发生问题的可能性
 */
public class BlockedSleep01 {
    static class Web12306 implements Runnable{
        //票数
        private int ticketNums=99;
        @Override
        public void run() {
            while (true){
                if (ticketNums<0){
                    break;
                }
                //模拟网络延时
                try {
                    Thread.sleep(200);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName()+"---->"+ticketNums--);
            }
        }
    }

    public static void main(String[] args) {
        //一份资源
        Web12306 web= new Web12306();
        System.out.println(Thread.currentThread().getName());
        //多个代理
        new Thread(web,"码畜").start();
        new Thread(web,"码农").start();
        new Thread(web,"码磺").start();
    }
}

sleep模拟龟兔赛跑的休息

package com.sxt.state;

/**
 * sleep模拟龟兔赛跑的休息
 *
 */
public class BlockedSleep02 {

        public static class Racer implements Runnable {
            private String winner;//胜利者

            @Override
            public void run() {
                for (int steps = 1; steps <= 100; steps++) {
                    //模拟休息
                    if (Thread.currentThread().getName().equals("兔子") && steps % 10 == 0) {
                        try {
                            Thread.sleep(100);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    System.out.println(Thread.currentThread().getName() + "--->" + steps);
                    //比赛是否结束
                    boolean flg = gameWinner(steps);
                    if (flg) {
                        break;
                    }
                }
            }

            private boolean gameWinner(int steps) {
                if (winner != null) {//存在胜利者
                    return true;
                } else {
                    if (steps == 100) {
                        winner = Thread.currentThread().getName();
                        System.out.println("winner==" + winner);
                        return true;
                    }
                }
                return false;
            }

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

sleep模拟倒计时

sleep是个静态方法

写在哪个线程体中，当前类对象谁运行我谁堵塞

sleep一般演示网络延时和倒计时

package com.sxt.state;

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

/**
 * sleep模拟倒计时
 */
public class BlockedSleep03 {
    public static void main(String[] args) throws InterruptedException {
        //倒数时
        Date endTime=new Date(System.currentTimeMillis()+1000*10);
        long end=endTime.getTime();
        while (true){
            System.out.println(new SimpleDateFormat("mm:ss").format(endTime));
            Thread.sleep(1000);
            endTime=new Date(endTime.getTime()-1000);
            if (end-10000>endTime.getTime()){
                break;
            }
        }
    }
}