2.1 创建线程

创建多线程程序有两种常用方法：实现 Runnable 接口或继承 Thread 类。

2.1.1 实现Runnable接口

Runnable 接口是一个函数式接口，它只有一个方法 void run() 。
在自定义类中实现 run 方法，然后用自定义类的实例构造一个 Thread 对象，最后调用对象的 start 方法启动线程。用lambda表达式可以简化这个过程，方便地创建实例：

  1. Runnable task = () -> {
  2.     // 任务代码
  3. }
  5. var t = new Thread(task);
  7. t.start();
  1. /**
  2. * 用lambda表达式创建线程
  3. */
  4. public class ThreadTest {
  6.     public static void main(String[] args) {
  8.         Runnable task1 = () -> {
  9.             try {
  10.                 for (int i = 0; i < 10; i++) {
  11.                     System.out.println(Thread.currentThread() + "hello");
  12.                     Thread.sleep((int) (100 * Math.random()));
  13.                 }
  14.             } catch (InterruptedException e) {}
  15.         };
  17.         Runnable task2 = () -> {
  18.             try {
  19.                 for (int i = 0; i < 10; i++) {
  20.                     System.out.println(Thread.currentThread() + "bye");
  21.                     Thread.sleep((int) (100 * Math.random()));
  22.                 }
  23.             }
  24.             catch (InterruptedException e) {}
  25.         };
  26.         new Thread(task1).start();
  27.         new Thread(task2).start();
  28.     }
  29. }

2.1.2 继承Thread

因为Thread类实现了Runnable接口，所以自定义类要重写run方法。为了简化创建线程的过程，可以用匿名内部类。

  1. //实现一个Thread的子类，只使用一次
  2. new Thread() {
  3.     @override
  4.     public void run() {
  5.         //任务代码
  6.     }
  7. }.start(); //线程启动

2.1.3 实现 Runnable 接口与 继承 Thread 相比有如下优势：

1、避免单继承带来的局限性；
2、任务与线程对象解耦，程序更健壮；
3、线程池技术不接受 Thread 的子类。