创建多线程程序的第一种方式：创建Thread类的子类 。
java.lang.Thread类：是描述线程的类，我们想要实现多线程程序，就必须继承Thread类。

实现步骤：

创建一个Thread类的子类。
在Thread类的子类中重写Thread类中的run方法，设置线程任务(开启线程要做什么？)。
创建Thread类的子类对象
调用Thread类中的方法start方法，开启新的线程，执行run方法。
         void start() 使该线程开始执行；java 虚拟机调用线程的 run 方法。

         结果是两个线程并行运行：当前线程(main线程)和另一个线程(创建新的线程，执行 run 方法)。

         多次启动一个线程是非法的。特别是当前线程已经结束执行后，不能再重新启动。

         java程序属于抢占式调度，哪个线程的优先级高，哪个线程优先执行；同一个优先级，随机选择一个执行

案例：

定义一个Thread类的子类：
package XianCheng.DuoThread;
 
//1. 创建一个Thread类的子类。
public class MyThread extends Thread{
    //2. 在Thread类的子类中重写Thread类中的run方法，设置线程任务(开启线程要做什么？)。
    @Override
    public void run() {
        for (int i = 0; i < 20; i++) {
            System.out.println("run:" + i);
        }
    }
}



使用这个子类
package XianCheng.DuoThread;
 
/*
    创建多线程程序的第一种方式：创建Thread类的子类
    java.lang.Thread类：是描述线程的类，我们想要实现多线程程序，就必须继承Thread类。
    实现步骤：
        1. 创建一个Thread类的子类。
        2. 在Thread类的子类中重写Thread类中的run方法，设置线程任务(开启线程要做什么？)。
        3. 创建Thread类的子类对象
        4. 调用Thread类中的方法start方法，开启新的线程，执行run方法。
            void start() 使该线程开始执行；java 虚拟机调用线程的 run 方法。
            结果是两个线程并行运行：当前线程(main线程)和另一个线程(创建新的线程，执行 run 方法)。
            多次启动一个线程是非法的。特别是当前线程已经结束执行后，不能再重新启动。
    java程序属于抢占式调度，哪个线程的优先级高，哪个线程优先执行；同一个优先级，随机选择一个执行
 */
public class Demo01Thread {
    public static void main(String[] args) {
        //3. 创建Thread类的子类对象
        MyThread mt = new MyThread();
 
        //4. 调用Thread类中的方法start方法，开启新的线程，执行run方法。
        mt.start();
 
        for (int i = 0; i < 20; i++) {
            System.out.println("main:" + i);
        }
    }
}



运行结果：

java程序属于抢占式调度，哪个线程的优先级高，哪个线程优先执行；同一个优先级，随机选择一个执行 

main:0
main:1
main:2
main:3
main:4
main:5
run:0
run:1
run:2
run:3
run:4
run:5





创建多线程程序的第一种方式：实现Runnable接口
java.lang.Runnable

               Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。

java.lang.Thread类的构造方法

               Thread(Runnable target) 分配新的 Thread 对象。

               Thread(Runnable target, String name) 分配新的 Thread 对象。

实现步骤：

创建一个Runnable接口的实现类
在实现类中重写Runnable接口的run方法，设置线程任务
创建一个Runnable接口的实现类对象
创建Thread类对象，构造方法中传递Runnable接口的实现类对象
调用Thread类中的start方法，开启新的线程执行run方法
案例：

定义一个Runnable接口的实现类：
package XianCheng.DuoThread;
 
//1. 创建一个Runnable接口的实现类
public class RunnableImpl implements Runnable{
    //2. 在实现类中重写Runnable接口的run方法，设置线程任务
    @Override
    public void run() {
        for (int i = 0; i < 6; i++) {
            System.out.println(Thread.currentThread().getName() + " --> " + i);
        }
    }
}

使用这个类：
package XianCheng.DuoThread;
 
/*
    创建多线程程序的第一种方式：实现Runnable接口
    java.lang.Runnable
        Runnable 接口应该由那些打算通过某一线程执行其实例的类来实现。类必须定义一个称为 run 的无参数方法。
    java.lang.Thread类的构造方法
        Thread(Runnable target) 分配新的 Thread 对象。
        Thread(Runnable target, String name) 分配新的 Thread 对象。
    实现步骤：
        1. 创建一个Runnable接口的实现类
        2. 在实现类中重写Runnable接口的run方法，设置线程任务
        3. 创建一个Runnable接口的实现类对象
        4. 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        5. 调用Thread类中的start方法，开启新的线程执行run方法
 */
 
public class Demo01Runnable {
    public static void main(String[] args) {
        //3. 创建一个Runnable接口的实现类对象
        RunnableImpl run = new RunnableImpl();
 
        //4. 创建Thread类对象，构造方法中传递Runnable接口的实现类对象
        Thread t = new Thread(run);
 
        //5. 调用Thread类中的start方法，开启新的线程执行run方法
        t.start();
 
        for (int i = 0; i < 6; i++) {
            System.out.println(Thread.currentThread().getName() + " --> " + i);
        }
    }
}


运行结果：

java程序属于抢占式调度，哪个线程的优先级高，哪个线程优先执行；同一个优先级，随机选择一个执行 

main --> 0
main --> 1
main --> 2
main --> 3
main --> 4
main --> 5
Thread-0 --> 0
Thread-0 --> 1
Thread-0 --> 2
Thread-0 --> 3
Thread-0 --> 4
Thread-0 --> 5