线程的创建方式
- 继承 `Thread` 类
- 实现 `Runnable` 接口
- 实现 `Callable` 接口
- - `Futrue、Callable、Runnable、FutureTask` 的继承关系
  - - `Callable` 接口
    - `Future` 接口
    - `RunnableFuture` 接口
    - `FutureTask` 类
  - 实现 `Callable` 接口创建线程
- 线程池创建线程
- - 线程池创建线程之 `Runnable`
  - 线程池创建线程之 `Callable`
`Runnable` 与 `Callable` 的区别
- `Runnable` 与 `Callable` 的源码
文章延伸
- 线程池的 `execute()` 和 `submit()` 区别

线程的创建方式

继承 Thread 类
实现 Runnable 接口
实现 Callable 接口
线程池创建线程

继承 `Thread` 类

public class ThreadTest extends Thread {@Overridepublic void run() {for (int i = 0; i < 10; i++) {System.out.println(Thread.currentThread().getName() + ":" + i);}}public static void main(String[] args) {new ThreadTest().start();new ThreadTest().start();}
}结果：可能每次结果不相同
Thread-0:0
Thread-1:0
Thread-0:1
Thread-1:1
................省略
Thread-1:8
Thread-0:8
Thread-1:9
Thread-0:9

实现 `Runnable` 接口

public class ThreadTest implements Runnable {@Overridepublic void run() {for (int i = 0; i < 20; i++) {System.out.println(Thread.currentThread().getName() + ":" + i);}}public static void main(String[] args) {Thread thread1 = new Thread(new ThreadTest());thread1.start();Thread thread2 = new Thread(new ThreadTest());thread2.start();}
}结果：可能每次结果不相同
Thread-0:0
Thread-1:0
Thread-0:1
Thread-1:1
................省略
Thread-0:8
Thread-1:8
Thread-0:9
Thread-1:9

实现 `Callable` 接口

`Futrue、Callable、Runnable、FutureTask` 的继承关系

public class FutureTask<V> implements RunnableFuture<V> {}public interface RunnableFuture<V> extends Runnable, Future<V> {void run();
}@FunctionalInterface
public interface Runnable {public abstract void run();
}public interface Future<V> {}

`Callable` 接口

是一个函数式接口，类泛型参数类型与返回值类型一致，call 方法相当于 Runnable 的 run() 方法，用来写线程的执行任务

@FunctionalInterface
public interface Callable<V> {V call() throws Exception;
}

`Future` 接口

Callable 接口只是单纯地去获得返回值，但是什么时候获取，或者查看线程的运行状态，就需要借助 Future。Future 提供了取消任务、获取任务执行的状态与获取结果的能力

public interface Future<V> {// 取消任务的执行，任务已经完成或者已经被取消时，调用此方法，会返回falseboolean cancel(boolean mayInterruptIfRunning);// 判断任务是否被取消boolean isCancelled();// 判断任务是否完成(正常完成、异常以及被取消，都将返回true)boolean isDone();// 阻塞地获取任务执行的结果V get() throws InterruptedException, ExecutionException;// 在一定时间内，阻塞地获取任务执行的结果V get(long timeout, TimeUnit unit)throws InterruptedException, ExecutionException, TimeoutException;}

`RunnableFuture` 接口

从名字上能看出来，RunnableFuture 继承了 Runnable 与 Future 接口，run 方法来自 Runnable 接口

public interface RunnableFuture<V> extends Runnable, Future<V> {void run();
}

以上说的，Runnable、Callable、Future 以及 RunnableFuture 都是接口，真正干活还得靠 FutureTask

`FutureTask` 类

FutureTask 实现了 RunnableFuture 接口，RunnableFuture 继承了 Runnable 与 Future 接口，因此 FutureTask 既可以作为一个 Runnable 被 Thread 执行，也可以获取到 Future 异步计算的结果

下面看看 FutureTask 类重写 Runnable 接口的 run() 方法

public class FutureTask<V> implements RunnableFuture<V> {public FutureTask(Callable<V> callable) {if (callable == null)throw new NullPointerException();this.callable = callable;this.state = NEW;       // ensure visibility of callable}public FutureTask(Runnable runnable, V result) {this.callable = Executors.callable(runnable, result);this.state = NEW;       // ensure visibility of callable}public void run() {if (state != NEW ||!UNSAFE.compareAndSwapObject(this, runnerOffset,null, Thread.currentThread()))return;try {Callable<V> c = callable;if (c != null && state == NEW) {V result;boolean ran;try {// 调用了传入的Callable的Call()方法result = c.call();ran = true;} catch (Throwable ex) {result = null;ran = false;setException(ex);}if (ran)set(result);}} finally {// runner must be non-null until state is settled to// prevent concurrent calls to run()runner = null;// state must be re-read after nulling runner to prevent// leaked interruptsint s = state;if (s >= INTERRUPTING)handlePossibleCancellationInterrupt(s);}}
}

可看出，run() 方法调用了传入的 Callable 的 call() 方法

实现 `Callable` 接口创建线程

public class CallableFutureTest {public static void main(String[] args) throws ExecutionException, InterruptedException {FutureTask futureTask = new FutureTask(new Callable() {@Overridepublic Object call() throws Exception {System.out.println(Thread.currentThread().getName());return 200;}});// FutureTask实现了Runnable接口，用Runnable创建一个线程// 注意这里，这里传入futureTask参数，构造了一个Threadnew Thread(futureTask).start();int result = (int) futureTask.get(); // 获取线程的最终结果System.out.println("result的结果：" + result);System.out.println("main come over");}
}结果：
Thread-0
result的结果：200
main come over

线程池创建线程

使用 ThreadPoolExecutor 类中的 execute() 方法来创建线程

关于线程池 ThreadPoolExecutor 类的详情：https://blog.csdn.net/weixin_38192427/article/details/117394526

线程池创建线程之 `Runnable`

public class ThreadPoolTest {public static void main(String[] args) {ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 100, TimeUnit.SECONDS,new ArrayBlockingQueue<>(100), new ThreadPoolExecutor.AbortPolicy());for (int i = 0; i < 10; i++) {threadPoolExecutor.execute(new Runnable() {@Overridepublic void run() {System.out.println(Thread.currentThread().getName());}});}/*关闭线程池*/threadPoolExecutor.shutdown();while (!threadPoolExecutor.isTerminated()) {}System.out.println("main come over");}
}结果：
pool-1-thread-1
pool-1-thread-1
pool-1-thread-2
pool-1-thread-3
pool-1-thread-1
pool-1-thread-3
pool-1-thread-2
pool-1-thread-1
pool-1-thread-4
pool-1-thread-5
main come over

线程池创建线程之 `Callable`

public class ThreadPoolTest2 {public static void main(String[] args) {ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(5, 10, 100, TimeUnit.SECONDS,new ArrayBlockingQueue<>(100), new ThreadPoolExecutor.AbortPolicy());for (int i = 0; i < 10; i++) {/*使用FutureTask的构造函数实例化*/FutureTask futureTask = new FutureTask(new Callable() {@Overridepublic Object call() throws Exception {System.out.println(Thread.currentThread().getName());return 200;}});/*由于FutureTask间接的实现了接口Runnable，所以此处可以传递参数futureTask*/threadPoolExecutor.execute(futureTask);}/*关闭线程池*/threadPoolExecutor.shutdown();while (!threadPoolExecutor.isTerminated()) {}System.out.println("main come over");}
}结果：
pool-1-thread-1
pool-1-thread-2
pool-1-thread-1
pool-1-thread-2
pool-1-thread-1
pool-1-thread-2
pool-1-thread-1
pool-1-thread-3
pool-1-thread-4
pool-1-thread-5
main come over

`Runnable` 与 `Callable` 的区别

`Runnable` 与 `Callable` 的源码

@FunctionalInterface
public interface Runnable {public abstract void run();
}@FunctionalInterface
public interface Callable<V> {V call() throws Exception;
}

Callcble 是有返回值的，返回值是通过实现 Future 接口的对象的 get 方法获取的，这个方法是会造成线程阻塞的；而 Runnable 是没有返回值的，因为 Runnable 接口中的 run() 方法是没有返回值的
Callable 里面的 call() 方法是可以抛出异常的，我们可以捕获异常进行处理；但是 Runnable 里面的 run() 方法是不可以抛出异常的，异常要在 run() 方法内部必须得到处理，不能向外界抛出

文章延伸

线程池的 `execute()` 和 `submit()` 区别

execute() 方法用于提交不需要返回值的任务，所以无法判断任务是否被线程池执行成功与否；execute() 方法的实现是 ThreadPoolExecutor 类中

public interface Executor {void execute(Runnable command);
}

submit() 方法用于提交需要返回值的任务。线程池会返回一个 Future 类型的对象，通过这个 Future 对象可以判断任务是否执行成功，并且可以通过 Future 的 get() 方法来获取返回值，get() 方法会阻塞当前线程直到任务完成，而使用 get(long timeout，TimeUnit unit) 方法则会阻塞当前线程一段时间后立即返回，这时候有可能任务没有执行完

public interface ExecutorService extends Executor {// ...........................省略<T> Future<T> submit(Runnable task, T result);// ...........................省略
}

public abstract class AbstractExecutorService implements ExecutorService {public Future<?> submit(Runnable task) {if (task == null) throw new NullPointerException();RunnableFuture<Void> ftask = newTaskFor(task, null);execute(ftask);return ftask;}public <T> Future<T> submit(Runnable task, T result) {if (task == null) throw new NullPointerException();RunnableFuture<T> ftask = newTaskFor(task, result);execute(ftask);return ftask;}// ......
}