package com.stulzl.exit_;

//线程终止案例  587
public class ThreadExit_ {
    public static void main(String[] args) throws InterruptedException {
        T t1 = new T();
        t1.start();
        //如果希望main线程去控制t1 线程的终止, 必须可以修改 loop
        //让t1 退出run方法，从而终止 t1线程 -> 称为 通知方式
        //让主线程休眠 10 秒，再通知 t1线程退出
        System.out.println("main线程休眠10秒");
        Thread.sleep(10*1000);//这里抛出异常，懒得捕获了
        t1.setLoop(false);
    }
}
class T extends Thread{
    private int count = 0;
    //设置一个变量
    private boolean loop = true;
    @Override
    public void run() {
        while(loop){
            try {
                Thread.sleep(50);// 让当前线程休眠50ms
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("T 运行中...." +(++count));
        }
    }

    public void setLoop(boolean loop) {
        this.loop = loop;
    }
}

package com.stulzl.thread_method01;

//线程常用方法注意细节01  588
//1. setName //设置线程名称，使之与参数name相同
//2. getName //返回该线程的名称
//3. start //使该线程开始执行; Java虚拟机底层调用该线程的 startO方法
//4. run //调用线程对象run方法;
//5. setPriority //更改线程的优先级
//6. getPriority //获取线程的优先级
//7. sleep //在指定的毫秒数内让当前正在执行的线程休眠(暂停执行)
//8. interrupt //中断线程
public class ThreadMethod01 {
    public static void main(String[] args) throws InterruptedException {
        //测试相关方法
        T t = new T();
        t.setName("旺财");//设置线程名称
        t.setPriority(Thread.MIN_PRIORITY);//更改线程的优先级//将线程优先级设置为最低
        t.start();//启动子线程

        //主线程打印5 hi ,然后我就中断 子线程的休眠
        for (int i = 0; i <5; i++) {
            Thread.sleep(1000);
            System.out.println("hi "+i);
        }
        System.out.println(t.getName() + " 线程的优先级 =" + t.getPriority());//1//获取线程的优先级
        
        t.interrupt();//中断线程 //当执行到这里，就会中断 t线程的休眠.
    }
}
class T extends Thread { //自定义的线程类
    @Override
    public void run() {
        while (true) {
            for (int i = 0; i < 100; i++) {
                //Thread.currentThread().getName() 获取当前线程的名称
                System.out.println(Thread.currentThread().getName() + "  吃包子~~~~" + i);
            }
            try {
                System.out.println(Thread.currentThread().getName() + " 休眠中~~~");
                Thread.sleep(20000);//20秒
            } catch (InterruptedException e) {
                //当该线程执行到一个interrupt 方法时，就会catch 一个 异常, 可以加入自己的业务代码
                //InterruptedException 是捕获到一个中断异常.
                System.out.println(Thread.currentThread().getName() + "被 interrupt了");
            }
        }
    }
}

package com.stulzl.thread_method02;

// yield:线程的礼让和 join:线程的插队案例  589
public class ThreadMethod02 {
    public static void main(String[] args) throws InterruptedException {
        T2 t2 = new T2();
        t2.start();
        for (int i = 1; i <=20; i++) {
            Thread.sleep(1000);
            System.out.println("主线程(小弟) 吃了"+i+" 包子");
            if(i==5){
                System.out.println("主线程(小弟) 让 子线程(老大) 先吃");
                //join, 线程插队
                //t2.join();// 这里相当于让t2 线程先执行完毕

                //yield:线程的礼让
                Thread.yield();//礼让，不一定成功..,因为cpu资源很充足，只有cpu资源紧缺时才可能成功
                System.out.println("线程(老大) 吃完了 主线程(小弟) 接着吃..");
            }
        }
    }
}
class T2 extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 20; i++) {
            try {
                Thread.sleep(1000);//休眠1秒
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("子线程(老大) 吃了 " + i +  " 包子");
        }
    }
}

package com.stulzl.thread_method_exercise01;

//1.主线程每隔1s,输出hi,一共10次    590
//2.当输出到hi 5时，启动一个子线程(要求实现Runnable),每隔1s输出hello,等该线程输出10次hello后,退出
//3.主线程继续输出hi,直到主线程退出，
//4.如图，完成代码其实线程插队..
public class Thread_Method_Exercise01 {
    public static void main(String[] args) throws InterruptedException {
        T t = new T();
        Thread thread = new Thread(t);//创建子线程
        for (int i = 1; i <= 10; i++) {
            System.out.println("hi "+i);
            Thread.sleep(1000);//输出一次hi让主线程休眠1秒
            if(i==5){//说明主线程输出了 5 次 hi
                thread.start();//启动子线程输出hello
                thread.join();//让子线程插队
            }
        }
    }
}
class T implements Runnable{
    @Override
    public void run() {
        for (int i = 1; i <= 10; i++) {
            System.out.println("hello "+i);
            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}