创建多线程的两种方法

创建线程的方法：

1. 一种方法是将类声明为 Thread 的子类。该子类应重写 Thread 类的 run 方法。接下来可以分配并启动该子类的实例。

   public class MyThread extends Thread{
       @Override
       public void run() {
           super.run();                      //继承Thread，并重写run方法，run函数里写要执行的代码
           for (int i = 0; i < 100; i++) {
               System.out.println("aaaaaa");
           }
       }
   }
   
   
       //主线程
       public static void main(String[] args) {
           MyThread myThread=new MyThread();       //创建线程子类对象
           myThread.start();                       //启动线程
           for (int i = 0; i < 100; i++) {         //这里的i要足够大
               System.out.println("主线程");
           }
       }

   1. 继承Thread ：  public class MyThread extends Thread
   2. 重写run()方法
   3. 将要执行的代码放在run()方法中
   4. 创建Thread的子类对象： MyThread myThread=new MyThread();
   5. 开启线程： myThread.start();下面是实例

2. 另一种方法时声明实现 Runnable 接口的类。该类然后实现 run 方法。然后可以分配该类的实例，在创建 Thread 时作为一个参数来传递并启动。

   实例：

   class MyRunnable implements Runnable{           //1.定义一个类实现Runnable
   
       public static void main(String[] args) {
           MyRunnable myRunnable=new MyRunnable();     //4.创建Runnable的子类对象
           Thread thread=new Thread(myRunnable);       //5.将其当做参数传递给Thread的构造函数
           thread.start();                             //6.开启线程
           for (int i = 0; i < 100; i++) {
               System.out.println("主线程");
           }
       }
   
       @Override
       public void run() {                         //2.重写run方法，3.将要执行的代码写在run方法中，
           for (int i = 0; i < 100; i++) {
               System.out.println("aaaaaa");
           }
       }
   }

3. 两种方法的区别：

   1. 继承Thread类：由于子类重写了Thread类的run方法，当调用start时，直接调用子类的run()方法。

   2. 实现Runnable：Thread构造函数中传入了Runnable的引用，成员变量记住了它，start()调用run()方法时内部判断Runnable的引用是否为空，不为空时：编译看的是Runnable的run(),运行看的是子类的run()方法。

   3. 好处与弊端：

      底层都是由Thread的start()方法调用run实现的，所以Thread方法更直接，代码更简单。

      但是Thread 方法是继承之后才能实现的，而Java是单继承，当类已经继承了其他类就需要使用第二种方法了（Runnable），应为Java接口可以多继承

4. 内部匿名类实现两种方法（常用）：

            //内部匿名类时实现继承Thread方法
           new Thread(){                   //1. new Thread(){}   继承Thread类，
               public void run(){          //2. 重写run方法
   
               }
           }.start();
           
           //内部匿名类时实现Runnable
           new Thread(new Runnable() {         //将Runnable的子类对象当做参数传递Thread的构造方法
               @Override
               public void run() {             //重写run方法
   
               }
           }).start();