/**
 * 1、关于线程的sleep方法：
 *      static void sleep(long millis)
 *      参数是毫秒
 *      作用：让当前进程进入休眠，进入“阻塞状态”，放弃占有的CPU时间片，让给其他线程使用
 *
 *  2、Thread.sleep()方法，可以间隔特定的时间，去执行一段代码，每隔多久执行一次
 *
 */
public class ThreadTest04 {
    public static void main(String[] args) {

       /* for (int i = 0; i < 10; i++) {
            System.out.println("输出后，睡眠一秒 ：" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }*/
        Thread mm = new Mm();
        mm.setName("mm");
        mm.start();
        try {
            mm.sleep(5000);
            //不要看这里是mm.sleep就会休眠mm线程
            //在执行的时候，还是会转换为Thread.sleep()方法的，让当前进程，也就是main进程进入休眠
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("我被休眠了，现在才好");
    }
}
class Mm extends Thread{
    @Override
    public void run() {
        for (int i = 0; i <10 ; i++) {
            System.out.println(Thread.currentThread().getName() +" -->" + i);
        }
    }
}
/*
* sleep睡眠太久，怎么唤醒一个正在睡眠的线程？
*   注意：这个中断不是线程的中断，而是线程睡眠的中断
* */

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

        Thread aa = new My01();
        System.out.println("主线程测试开始");
        aa.start();

        //5秒之后，分支线程起来，因为主线程里的活干完了（其实是主线程也睡了5秒钟）
        try {
            aa.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //中断线程的睡眠，（这种中断睡眠的方法依靠的是java的异常处理机制）
        //注意：这里只有aa.start（）所以，默认的是终止的是分支线程
        aa.interrupt();
        System.out.println("测试结束");
        //说明一下，这里为什么输出语句，不是在最后输出的，而是和最后两句同时输出的，这是因为线程并发执行的，
        //aa.interrupt();

        /*测试开始
        开始执行，下面准备睡眠很长时间
        测试结束
        没睡好，就被叫起来干活
        开始干活*/



        //如果没有的话，是不是终止的是主线程呢
        //  经过测试，是不行的，主线程不能被终止，这和java自然而下执行的亘古不变原则，有冲突
        /*try {
            Thread.sleep(1000 * 5);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        Thread.interrupted();*/

    }
}
class My01 extends Thread{

    /**
     * 这个run方法的有异常只能catch，不能往外抛出，
     * 因为父类Thread中的run，就没有往外抛，子类不能比父类抛出更多的异常
     *     public void run() {
     *         if (target != null) {
     *             target.run();
     */

    @Override
    public void run() {
        System.out.println("分支线程开始执行，下面准备睡眠很长时间");

        try {
            Thread.sleep(1000 * 60 * 60 * 24);
        } catch (InterruptedException e) {
            //e.printStackTrace();
            System.out.println("没睡好，就被叫起来干活");
        }
        System.out.println("开始干活");

    }


}
/**
 * java中怎么强行终止一个线程的执行？
 *      stop方式有很大的缺点，容易丢失数据，因为这种方式将线程直接杀死了
 *      线程没有保存的数据会丢失，不建议使用
 */
public class ThreadTest06 {
    public static void main(String[] args) {

        Thread tt = new My06();
        tt.start();

        try {
            tt.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //已过时，不建议使用，强行终止进程(直接把线程给干死了）
        tt.stop();
    }
}
class My06 extends Thread{
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + "---->" + i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}
/**
 * 怎么合理的终止一个线程的执行，这种方式是很常用的
 */
public class ThreadTest07 {
    public static void main(String[] args) {

        My066 aa = new My066();
        aa.setName("aa");
        aa.start();

        //主线程睡眠5秒后，终止分支线程
        try {
            aa.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        aa.run01 = false;

    }
}
class My066 extends Thread{

    //打一个布尔标记
    boolean run01 = true;

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            if(run01){
                try {
                    System.out.println(Thread.currentThread().getName() + "-->" + i);
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }else {

                //这里可以save。。。。。
                return;
            }

        }

    }
}