创建线程的几种方式

严格来讲，创建线程只有一种方式，就是实现Runnable接口，其他创建线程的方式也是对其封装。

 继承Thread方式

public class Thread extends java.lang.Thread {
    @Override
    public void run() {
        super.run();
    }
}

进入Thread可以看到，也是实现了Runnable类。

通过这种方式创建的线程有两个缺点：

1. 线程执行后没有返回值。

2. java是单继承，意味着只能继承一个类，如果继承了Thread就无法继承其他类了

实现Runnable接口创建线程

public class Thread implements Runnable {
    @Override
    public void run() {
    }
}

这种就是比较原始的方式创建线程，缺点就是没有返回值，不过可以继续继承其他类了。

实现Callable接口

这种方式就可以有返回值了。

public class Thread implements Callable<String> {

    @Override
    public String call() {
        return "返回值";
    }

    public static void main(String[] args) {
        FutureTask<String> futureTask = new FutureTask<>(new Thread());
        java.lang.Thread thread = new java.lang.Thread(futureTask);
        thread.start();

        try {
            String s = futureTask.get();
            System.out.println(s);
        } catch (ExecutionException | InterruptedException e) {
            throw new RuntimeException(e);
        }
    }

}

使用线程池

这种方式更加强大，并且Executors提供了很多强大的方法，推荐了解。

public class Thread implements Runnable {
    public static void main(String[] args) {
        ExecutorService executorService = Executors.newFixedThreadPool(10);
        executorService.execute(new Thread());

    }

    @Override
    public void run() {
        System.out.println("使用线程池创建");
    }
}

扩展

还有一些其他方式去创建线程，比如内部类，lambda表达式创建线程，不过这些都是通过函数式接口的方式，一个类只且只有一个方法就是函数式接口。

例如内部类的方式，本质还是通过实现Runnable去做的，大家可以看到new了Runable的对象。

public class Thread {
    public static void main(String[] args) {
        new java.lang.Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("通过内部类的方式创建");
            }
        }).start();
    }
}

例如Lambda表达式的方式，也是基于Runnable。

public class Thread {
    public static void main(String[] args) {
        new java.lang.Thread(() -> System.out.println("通过内部类的方式创建")).start();
    }
}

因为Runnable是一个函数式接口，所以可以通过这两种方式去创建，可以看下Runnable类。

@FunctionalInterface：将类标记为一个函数式接口。