创建线程的四种方式

直接上代码：

import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.concurrent.*;

/**
 * @Description 创建线程的四种方式
 * @Author 张安
 * @Date 2020/11/3 15:48
 * @Version 1.0.0
 */
public class CreateThread {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ThreadOne threadOne = new ThreadOne();
        Thread thread = new Thread(new ThreadTwo());

        //执行Callable接口的任务
        Task<Object> callTask = new Task("测试Callable任务");
        FutureTask<Object> task = new FutureTask<>(callTask);
        Thread thread1 = new Thread(task);

        threadOne.start();
        thread.start();
        thread1.start();
        //注意如果Callable任务没有计算完毕，那么get()会一直阻塞到计算出结果为止
        System.out.println(task.get().toString());


    }
}

/**
 * @Description 第一种：直接继承Thread类，重写run()方法
 * Thread类也是一个实现了runnable接口的实例
 **/
class ThreadOne extends Thread {

    @Override
    public void run() {
        System.out.println("这是直接继承Thread类的...");
    }
}

/**
 * @Description 第二种：如果已经继承了一个类那么就无法再继承Thread
 * 可以实现Runnable接口，实现run()方法
 * 创建方式略有不同，新建一个Thread类，将这个实现Runnable接口的对象传入
 * 具体参考Thread源码，Thread的constructor()方法
 **/
class ThreadTwo implements Runnable {

    @Override
    public void run() {
        System.out.println("这是直接继承Runnable接口的...");
    }
}
/***
 * @Description 第三种：实现CallAble接口
 * 该种方式是有返回结果的线程，执行需要借助FutureTask类
 **/
class Task<Object> implements Callable<Object>{

    private String taskName;
    public Task(String taskName){
        this.taskName = taskName;
    }

    @Override
    public Object call() throws Exception {
        System.out.println(taskName+"任务启动...");
        Date dateTmp1 = new Date();
        Thread.sleep(1000);
        Date dateTmp2 = new Date();
        //1000ms = 1s
        long time = dateTmp2.getTime() - dateTmp1.getTime();
        return (Object) (taskName+"返回的结果和执行任务所使用的时间："+time+"ms");
    }
}
/***
 * @Description 第四种：使用Executor框架创建一个有返回值的线程池
 * ExecutorService提供了submit()方法，传递一个Callable，或Runnable，返回Future。
 * 如果Executor后台线程池还没有完成Callable的计算，这调用返回Future对象的get()方法，会阻塞直到计算完成。
 **/
class HasResult {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //定义线程池的大小
        int taskSize = 5;
        //创建一个固定大小的线程池
        ExecutorService taskPool = Executors.newFixedThreadPool(taskSize);
        //用来存放线程执行完的返回结果
        List<Future> list = new ArrayList<>();
        //创建多个实现Callable的线程
        for (int i= 0; i <taskSize; i++){
            Callable call = new Task("任务"+i);
            Future f = taskPool.submit(call);
            list.add(f);
        }
        //关闭线程池
        taskPool.shutdown();
        //将执行的结果打印到控制台
        for (Future future : list) {
            System.out.println("执行的结果：" + future.get().toString());
        }
    }
}