1.new Thread：
  1.     public static void test1() {
  2.         Thread t = new Thread() {
  3.             //执行的方法
  4.             @Override
  5.             public void run() {
  6.                 log.debug("running");
  7.             }
  8.         };
  9.         //命名线程
  10.         t.setName("t1");
  11.         //启动线程
  12.         t.start();
  13.     }

2.使用Runnable配合Thread（将需要执行的任务与创建线程分离，更灵活）
  1.     public static void main(String[] args) {
  2.        Runnable r = new Runnable() {
  3.            @Override
  4.            public void run() {
  5.               log.debug("running");
  6.            }
  7.        };
  8.         Thread t = new Thread(r, "t2");
  9.         t.start();
  10.     }

原理：Thread和Runnable的关系

方法一：实际上是手动重写了run方法，就会执行子类的run方法

方法二：在构造器中传入一个Runnable实例，内部在初始化方法将runnable实例赋值给了Thread中的一个成员变量。Thread类中的Run方法会判断runnable对象是否为null，不为null就运行Thread的run方法

总结：
  1. 方法一就是把线程和任务合并，方法二就是把线程和任务分开了
  3. 用Runnable更容易与线程池等高级API配合
  5. 用Runnable让任务脱离了Thread继承体系，更灵活

3.FutureTask 配合 Thread

FutureTask 能够接收 Callable 类型的参数，用来处理有返回结果的情况

  1.     public static void main(String[] args) throws Exception {
  2.         // 创建任务对象
  3.         FutureTask<Integer> task3 = new FutureTask<>(() -> {
  4.             log.debug("hello");
  5.             return 100;
  6.         });
  7.         // 参数1 是任务对象; 参数2 是线程名字，推荐
  8.         new Thread(task3, "t3").start();
  9.         // 主线程阻塞，同步等待 task 执行完毕的结果
  10.         Integer result = task3.get();
  11.         log.debug("结果是:{}", result);
  12.     }