Thread

Java种可以使用Thread类来创建线程：语法

步骤：

1. 指定执行线程的目标：定义一个Thread子类，重写run方法，将相关的逻辑实现

   public void **run**（）：将需要的逻辑写在里面，该方法相当于线程种的main方法

2. 创建自定义线程的子类对象

3. 开启线程操作 - 触发

public void start（）：只要调用了这个方法，线程才会启动，开始执行

Thread中的相关的方法：
public final String getName（）：获取到线程的名字
public final void setName（）：设置线程的名字
public static Thread currentThread（）：获取当前的线程对象
yield（）：释放当前cpu的执行权
join（）：在线程A中调用线程B的join（）方法，此时线程A就进入阻塞状态直到线程B完全执行完以后，线程A才结束阻塞状态
stop（）：强制线程生命期结束，不推荐使用（过时）
sleep（）：让当前线程“睡眠”指定的millitime毫秒。在指定的millitime毫秒是时间内，当前线程是阻塞状态
isAlive（）：判断当前线程是否还存活

线程的运行默认是不可控的，是CPU随机调用的，我们只能看到运行的结果

package ThreadDemo;/*
    @create 2021--01--05--20:36
*/
public class ThreadTest2 {
    public static void main(String[] args) {
        MyThread1 myThread1 = new MyThread1("Thread:1");
        MyThread2 myThread2 = new MyThread2();
        //myThread1.setName("线程一");
        myThread2.setName("线程二");
        myThread1.start();
        myThread2.start();
        Thread.currentThread().setName("主线程");
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                System.out.println(Thread.currentThread().getName() + "-->" + i);
            }
            if (i == 20) {
                try {
                    myThread1.join();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println(myThread1.isAlive());
    }
}
class MyThread1 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 == 0) {
                try {
                    sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println(Thread.currentThread().getName() + "-->" + i);
            }
            if (i % 20 == 0) {
                this.yield();
            }
        }
    }
    //构造器方式给线程命名
    public MyThread1(String name) {
        super(name);
    }
}
class MyThread2 extends Thread {
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            if (i % 2 != 0) {
                System.out.println(Thread.currentThread().getName() + "-->" + i);
            }
        }
    }
}

package Test21_Demo.Demo10;/*

    @create 2020--12--14--15:19
*/

/**
 * 自定义线程类
 * <p>
 * 定义一个Thread的子类！
 *
 * 创建线程的第一种方式：继承Thread类
 */
public class MyThread extends Thread {

    //重写run方法 - 相关的逻辑
    @Override
    public void run() {
        for (int i = 0; i < 50; i++) {
            /**
             * this表示当前正在被调用的线程
             * 获取线程的名字是Java干的事情（Java定义的），我们不管，只要看就行
             */
            System.out.println(this.getName() + " : " + i);
        }
    }
}

package Test21_Demo.Demo10;/*

    @create 2020--12--14--15:12
*/

public class ThreadDemo {
    //主线程
    public static void main(String[] args) {
        //创建线程对象    -   用于开启线程
        Thread t1 = new MyThread();
        Thread t2 = new MyThread();

        //开启线程 - 会直接运行
        t1.start();
        t2.start();
        System.out.println("_______________________________");

        //返回一个main线程 - 其实就是main方法的线程
        Thread mainThread = Thread.currentThread();
        System.out.println(mainThread);//Thread[main,5,main]

        for (int i = 0; i < 50; i++) {
            System.out.println(mainThread.getName() +" : "+ i);
        }
    }
}

第二种方式：
步骤：

1. 指定线程执行的目标：定义Runnable接口，并且实现接口，重写run方法，指定目标逻辑
2. 通过指定线程执行目标的构造方法创建线程对象

public Thread（Runnable target）
创建线程并且执行目标对象
通过线程执行目标对象创建线程对象

package Test21_Demo.Demo10;/*

    @create 2020--12--14--15:36
*/

/**
 *创建线程的第二种方式
 * 实现Runnable接口
 *
 * 1.实现接口，并且要实现run方法
 * 2.在run方法中添加逻辑代码
 * 3.通过start启动线程
 */
public class MyRunnable implements Runnable{

    @Override
    public void run() {
        //返回当前线程
        Thread thisThread = Thread.currentThread();
        for (int i = 0; i < 20; i++) {
            System.out.println(thisThread.getName() + " : " + i);
        }
    }
}

package Test21_Demo.Demo10;/*

    @create 2020--12--14--15:12
*/

/**
 * 第二种方式：
 */
public class ThreadDemo2 {
    //主线程
    public static void main(String[] args) {
        //创建线程执行目标
        MyRunnable mr = new MyRunnable();//线程对象 - 任务
        //通过指定线程执行目标的构造函数来创建线程
        Thread thread1 = new Thread(mr);//线程名称
        thread1.setName("Jack");
        Thread thread2 = new Thread(mr);//线程名称
        thread2.setName("Rose");

        //开启线程
        thread1.start();
        thread2.start();
    }
}