方式一：继承Thread类的方式：

1. 创建一个继承于Thread类的子类
2. 重写Thread类的run()—>将此线程执行的操作声明在run()中
3. 创建Thread类的子类的对象

4. 通过此对象调用start()：1.启动当前线程 2.调用当前线程的run()

   //1.创建一个继承于Thread类的子类
   class MyThread extends Thread{
    //2.重写Thread类的run()
    @Override
    public void run() {
        for (int i = 1; i < 100; i++) {
            if (i%2 ==0 ) {
                System.out.println(Thread.currentThread().getName()+":"+i);
            }
        }
    }
   }
   public class ThreadTest {
    public static void main(String[] args) {
        //3.创建Thread类的子类的对象
        MyThread n=new MyThread();
        //4.通过此对象调用start():1.启动当前线程 2.调用当前线程的run()
        n.start();
        //问题一：我们不能通过直接调用run()的方法启动线程。
   //        n.run();
        //问题二：再启动一个线程，遍历100以内的偶数，不可以还让已经start()的线程去执行，会报IllegalThreadStateException
   //        n.start();
        //我们需要重新创建一个线程的对象
        MyThread n1=new MyThread();
        n1.start();
        //如下操作仍是在main线程中执行的。
        for (int i = 1; i < 100; i++) {
            if (i%2 == 0) {
                System.out.println(Thread.currentThread().getName()+":"+i + "**main**");
            }
        }
    }
   }

说明两个问题：

1. 问题一：我们启动一个线程，必须调用start()，不能调用run()的方式启动线程。
2. 问题二：如果在启动一个线程，必须重新创建一个Thread子类的对象，调用此对象的start()。

方式二：实现Runnable接口的方式：

1. 创建一个实现了Runnalbe接口的类
2. 实现类去实现Runnalbe中抽象方法：run()
3. 创建实现类的对象
4. 将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
5. 通过Thread类的对象调用start()

//1.创建一个实现了Runnalbe接口的类
class MThread implements Runnable{
    //2.实现类去实现Runnalbe中的抽象方法：run()
    @Override
    public void run() {
        for (int i = 0; i < 100; i++) {
            System.out.println(Thread.currentThread().getName() + ":" + i);
        }
    }
}
public class ThreadTest1 {
    public static void main(String[] args) {
        //3.创建实现类的对象
        MThread m=new MThread();
        //4.将此对象作为参数传递到Thread类的构造器中，创建Thread类的对象
        Thread test1=new Thread(m);
        test1.setName("线程一");
        //5.通过Thread类的对象调用start()
        test1.start();
        //在启动一个线程，遍历100以内的偶数
        Thread test2=new Thread(m);
        test2.setName("线程二");
        test2.start();
    }
}

两种方式的对比：

• 开发中：优先选择：实现Runnalbe接口的方式
  • 原因
    • 1.实现的方法没有类的单继承的局限性
    • 2.实现的方式更合适来处理多个线程共享数据的情况
• 联系：public class Thread implements Runnalbe
• 相同点
  • 两种方式都需要重写run()，将线程要执行的逻辑声明在run()中
  • 目前两种方式，要启动线程，都是调用的Thread类中的start()