创建线程有几种不同的方式？你喜欢哪一种？为什么？

/**
 * @Author qgfzzzzzz
 * @Date 2019/8/19
 * @Version 1.0
 * <p>
 *  通过继承Thread类创建线程
 * </p>
 */
public class MyThreadOne extends Thread {
    @Override
    public void run() {
        for(int i = 0; i < 100; i++){
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }
    public static void main(String[] args){
        new MyThreadOne().start();
        new MyThreadOne().start();
    }
}

/**
 * @Author qgfzzzzzz
 * @Date 2019/8/19
 * @Version 1.0
 * <p>
 * 通过实现Runnable接口创建线程
 * </p>
 */
public class MyThreadTwo implements Runnable{
    @Override
    public void run() {
        for(int i = 0; i < 100; i++){
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
    }
    public static void main(String[] args){
        MyThreadTwo myThreadTwo = new MyThreadTwo();
        Thread th1 = new Thread(myThreadTwo, "thread-1");
        Thread th2 = new Thread(myThreadTwo, "thread-2");
        th1.start();
        th2.start();
    }
}

import java.util.concurrent.Callable;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.FutureTask;

/**
 * @Author qgfzzzzzz
 * @Date 2019/8/19
 * @Version 1.0
 * <p>
 * 通过实现Callable接口创建线程
 *
 * 实现Callable接口
 * 1】创建Callable接口的实现类，并实现call()方法，然后创建该实现类的实例
 * 2】使用FutureTask类来包装Callable对象，该FutureTask对象封装了Callable对象的call()方法的返回值
 * 3】使用FutureTask对象作为Thread对象的target创建并启动线程（因为FutureTask实现了Runnable接口）
 * 4】调用FutureTask对象的get()方法来获得子线程执行结束后的返回值
 * </p>
 */
public class MyThreadThree implements Callable<Integer> {
    public static void main(String[] args) {
        MyThreadThree myThreadThree = new MyThreadThree();
        FutureTask<Integer> ft = new FutureTask<>(myThreadThree);
        FutureTask<Integer> ft1 = new FutureTask<>(myThreadThree);
        System.out.println(Thread.currentThread().getName() + "===== ");

        new Thread(ft, "thread-1").start();
        new Thread(ft1, "thread-2").start();
        try {
            System.out.println("return thread-1'result ：" + ft.get());
            System.out.println("return thread-2'result ：" + ft1.get());
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
    }

    @Override
    public Integer call() throws Exception {
        for (int i = 0; i < 10; i++) {
            System.out.println(Thread.currentThread().getName() + " " + i);
        }
        return 20;
    }
}

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * @Author qgfzzzzzz
 * @Date 2019/8/19
 * @Version 1.0
 * <p>
 * Executors执行Runnable任务
 * </p>
 */
public class MyThreadFour implements Runnable {
    @Override
    public void run() {
        System.out.println(Thread.currentThread().getName() + " is called");
    }
    public static void main(String[] args){
        ExecutorService executorService = Executors.newCachedThreadPool();
        for(int i = 0; i < 5; i++){
            executorService.execute(new MyThreadFour());
        }
        executorService.shutdown();
    }
}

import java.util.ArrayList;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;

/**
 * @Author qgfzzzzzz
 * @Date 2019/8/19
 * @Version 1.0
 * <p>
 * Executors执行Callable任务
 * </p>
 */
public class MyThreadFive {

    // 业务线程
    private class AThread implements Callable<String> {
        private int id;
        public AThread(int id){
            this.id = id;
        }
        @Override
        public String call() {
            System.out.println("线程:" + id + " 运行..");
            try {
                Thread.sleep(3000);
            } catch (Exception e) {
                e.printStackTrace();
            }

            System.out.println("线程:" + id + " -> 结束.");
            return "返回的字符串" + id;
        }
    }

    public void ExecutorService() {
        ExecutorService pool = Executors.newFixedThreadPool(4);
        ArrayList<Future<String>> futures = new ArrayList<>();

        for (int i = 0; i < 10; i++) {
            AThread t = new AThread(i);
            // Runnable -> execute()
            // Callable -> submit()
            Future<String> f = pool.submit(t);
            futures.add(f);
        }
        System.out.println("....开始获取结果中...");
        // Future的get方法在获取结果时候将进入阻塞，阻塞直到Callable中的call返回。
        for (Future<String> f : futures) {
            try {
                System.out.println(f.get());
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        System.out.println(".....结束得到结果....");
        pool.shutdown();
    }
    public static void main(String[] args) {
        new MyThreadFive().ExecutorService();
    }
}