package com.example.www.d4;
/**
 * @ClassName ThreadTest
 * @Description 多线程的实践
 * @Author Jack
 * @Date 2021/11/21 20:58
 * @Version 1.0
 */
/**
 * 多线程的创建：方式一：继承于Thread类
 * 1、创建一个继承Thread类的子类
 * 2、重写Tread类的run（）方法 -->将此线程执行的操作声明在方法体中
 * 3、创建Thread类的子类的对象
 * 4、通过此对象调用start（）
 * <p>
 * 实例：遍历100以内的所有偶数
 */
//1.创建一个继承Thread类的子类
class MyThread extends Thread {
    //2.重写run方法
    @Override
    public void run() {
        for (int i = 0; i < 101; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + ":" + i);
            }
        }
    }
}
public class ThreadTest {
    public static void main(String[] args) {
        //3.创建Thread类的子类的对象
        MyThread t1 = new MyThread();
        //4.通过此对象调用start（）
        t1.start();//导致此线程开始执行; Java虚拟机调用此线程的run方法。
        //问题一：我们不能通过调用run的方法启动线程
//        myThread.run(); //不会开启新的线程
        //问题二：再启动一个线程，遍历100以内的偶数，不可以让已经start（）的线程去执行，会报illegalThread异常
        //我们需要重新创建一个线程的对象，也就是说重新创建一个Thread子类的对象
        MyThread t2 = new MyThread();
        t2.start();
        //如下操作仍是在main线程中执行
        for (int i = 0; i < 101; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName() + "" + "**********hello********");
            }
        }
    }
}

package com.example.www.d4;
/**
 * @ClassName ThreadTest1
 * @Description 创建多线程的方式二：实现Runnable接口
 * 1.创建一个实现了Runnable接口的类
 * 2.实现类去实现Runnable中的抽象方法：run（）
 * 3.创建实现类的对象
 * 4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
 * 5.调用start（）启动当前线程，调用当前线程的run（）
 * @Author Jack
 * @Date 2021/11/22 7:27
 * @Version 1.0
 */
//1.创建实现类
class MyThread3 implements Runnable{
    //2.实现Runnable中的抽象方法
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName()+":"+i);
        }
    }
}
public class ThreadTest1 {
    public static void main(String[] args) {
        //3.创建实现类的对象
        MyThread3 t3 = new MyThread3();
        //4.将此对象作为参数传递到Thread的构造方法中
        Thread t = new Thread(t3);
        //5.通过Thread类的对象调用start 启动线程，调用当前线程的run-->调用了Runnable类型的target
        t.start();
    }
}

package com.example.www.d4;
/**
 * @ClassName ThreadMethodTest
 * @Description Thread的常用方法
 * 1.start（）：启动当前线程，调用当前线程的run（）
 * 2.run（）：通常需要重写Thread类中的此方法，将创建线程要执行的操作写在里面
 * 3.currentThread：静态方法，返回当前代码的线程
 * 4.getName（）获取当前线程的名词
 * 5.setName设置当前线程的名字
 * 6.yield（）：释放当前cpu执行权
 * 7.join（）：在线程a中调用线程b的join，此时线程a进入阻塞状态，直到线程b执行完毕，线程a才结束阻塞状态
 * 8.stop()已过时，当执行此方法时，强制结束当前线程
 * 9.sleep（long milltime）:让当前线程睡眠指定的millitime毫秒，在指定时间内线程属于阻塞状态
 * 10.isAlive()判断线程是否存活
 * <p>
 * <p>
 * 线程的优先级
 * 1.
 * MAX_PRIORITY 10
 * MIN_PRIORITY 1
 * NORM_PRIORITRY 5
 * 2.如何获取和设置当前线程的优先级
 * getPriority():获取线程的优先级
 * setPriority():设置线程的优先级
 * @Author Jack
 * @Date 2021/11/21 22:14
 * @Version 1.0
 */
public class ThreadMethodTest {
    public static void main(String[] args) {
        MyThread2 t1 = new MyThread2();
        t1.setName("线程1");
        //设置分线程的优先级
        t1.setPriority(Thread.MAX_PRIORITY);
        t1.start();
        Thread.currentThread().setName("主线程");
        Thread.currentThread().setPriority(Thread.MIN_PRIORITY);
        for (int i = 1; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + Thread.currentThread().getPriority() + ":" + i);
//            if (i % 20 ==0){
//                try {
//                    t1.join();
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
//            }
        }
        System.out.println(t1.isAlive());
    }
}
class MyThread2 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
//                try {
//                    sleep(20);
//                } catch (InterruptedException e) {
//                    e.printStackTrace();
//                }
                System.out.println(Thread.currentThread().getName() + ":" + getPriority() + ":" + i);
            }
//            if (i == 20) {
//                yield();//释放当前cpu的执行权
            //线程1:80
            //主线程:75
            //....当线程1释放当前cpu执行权的时候，其他线程会进行抢夺
//            }
        }
    }
}