创建线程的两种方式

• 继承方式

• 实现方式

继承 Thread 类

1. 定义子类继承 Thread 类。

2. 子类中重写 Thread 类中的 run() 方法。

   /**
    * 继承 Thread 类的方式实现多线程
    */
   // 1.定义子类继承 Thread 类。
   public class ThreadDemo extends Thread{
       // 2.子类中重写 Thread 类中的 run() 方法
       @Override
       public void run() {
           System.out.println("多线程运行的代码");
           for (int i = 0; i < 5; i++) {
               System.out.println("这是多线程的逻辑代码" + i);
           }
       }
   }
   

3. 创建 Thread 子类对象，即创建了线程对象。

4. 调用线程对象 start 方法：启动线程，调用 run() 方法。

   public class Test {
       public static void main(String[] args) {
           // 3.创建 Thread 子类对象，即创建了线程对象
           Thread t0 = new ThreadDemo();
           // 4.调用线程对象 start 方法：启动线程，调用 run() 方法。
           //启动线程,开始运行 run() 方法中的代码
           t0.start();
   
           Thread t1 = new ThreadDemo();
           t1.start();
   
           System.out.println("-------------");
           System.out.println("-------------");
           System.out.println("-------------");
   
       }
   }
   

注意！！！！！

• 多线程的异步：开启线程之后，run() 方法中运行的代码主程序中 xx.start() 之后的程序是并行运行的，没有先后关系，这就叫异步

实现 Runnable 接口

1. 定义子类，实现 Runnable 接口。

2. 子类中重写 Runnable 接口中的 run() 方法。

   /**
    * 通过实现 Runnable 接口方式实现多线程
    */
   // 1.定义子类，实现 Runnable 接口。
   public class RunnableDemo implements Runnable{
       // 2.子类中重写 Runnable 接口中的 run() 方法。
       @Override
       public void run() {
           System.out.println("Runnable多线程 " + Thread.currentThread().getName() + " 运行的代码");
           for (int i = 0; i < 5; i++) {
               System.out.println("这是Runnable多线程 " + Thread.currentThread().getName() + " 的逻辑代码：" + i);
           }
       }
   }
   

3. 通过 Thread 类含参构造器创建线程对象。

4. 将 Runnable 接口的子类对象作为实际参数传递给 Thread 类的构造方法中。

5. 调用 Thread 类的 start() 方法：开启线程，调用 Runnable 子类接口的 run() 方法。

   public class Test {
       public static void main(String[] args) {
           // 3.通过 Thread 类含参构造器创建线程对象。
           // 4.将 Runnable 接口的子类对象作为实际参数传递给 Thread 类的构造方法中。
           // 不加线程名创建线程对象
           Thread t0 = new Thread(new RunnableDemo());
           // 5.调用 Thread 类的 start() 方法：开启线程，调用 Runnable 子类接口的 run() 方法。
           t0.start();
   
           // 加线程名创建线程对象，线程名为 t-1
           Thread t1 = new Thread(new RunnableDemo(),"t-1");
           t1.start();
   
           System.out.println(1);
           System.out.println(2);
           System.out.println(3);
       }
   }
   

继承方式和实现方式的联系和区别

public class Thread extends Object implements Runnable

• 区别：

  • 继承 Thread：线程代码存放 Thread 子类 run() 方法中。（重写 run() 方法）
  • 实现 Runnable：线程代码存在接口的子类的 run() 方法中。（实现 run() 方法）
  • 一般使用的都是实现接口的方式来实现多线程

• 实现接口方式的好处

  • 避免了单继承的局限性

  • **多个线程可以共享同一个接口实现类的对象，非常适合多个相同线程来处理同一份资源。**例如：

    // 创建实现类的对象
    Runnable run = new RunnableDemo();
    
    Thread t0 = new Thread(run,"t-0");
    t0.start();
    
    Thread t1 = new Thread(run,"t-1");
    t1.start();
    

使用多线程的优点

• 多线程程序的优点：
  1. 提高应用程序的响应，对图形化界面更有意义，可增强用户体验。
  2. 提高计算机系统 CPU 的利用率
  3. 改善程序结构。将又长又复杂的进程分为多个线程，独立运行，有利于理解和修改。