Java 异步多线程有哪些实现方式？

---

前言

异步多线程的四种方式：

1. 继承Thread
2. 实现Runnable接口
3. 实现Callable+FutureTask
4. 线程池

一、继承Thread

public class ThreadTest {
    public static void main(String[] args) {
        System.out.println("main 开始");
        Thread01 thread01 = new Thread01();
        thread01.start();
        System.out.println("main 结束");
    }

    public static class Thread01 extends Thread{
        public void run() {
            System.out.println("当前线程:"+Thread.currentThread( ).getId());
            int i = 10 / 2;
            System.out.println("运行结果:"+i);
        }
    }
}

main 开始
main 结束
当前线程:12
运行结果:5

二、实现Runnable接口

public class ThreadTest {
    public static void main(String[] args) {
        System.out.println("main 开始");
        Runnable01 runnable01 = new Runnable01();
        Thread thread = new Thread(runnable01);
        thread.start();
        System.out.println("main 结束");
    }

    public static class Runnable01 implements Runnable{
        @Override
        public void run() {
            System.out.println("当前线程:"+Thread.currentThread( ).getId());
            int i = 10 / 2;
            System.out.println("运行结果:"+i);
        }
    }
}

main 开始
main 结束
当前线程:12
运行结果:5

三、Callable+FutureTask

futureTask.get() 可以阻塞线程，等待线程返回值返回

public class ThreadTest {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main 开始");
        FutureTask<Integer> futureTask = new FutureTask(new Callable01());
        futureTask.run();//new Thread(futureTask).start();
        //阻塞线程 等待线程返回值返回
        Integer o = futureTask.get();
        System.out.println("线程返回值"+o);
        System.out.println("main 结束");
    }

    public static class Callable01 implements Callable<Integer> {
        @Override
        public Integer call() {
            System.out.println("当前线程:"+Thread.currentThread( ).getId());
            int i = 10 / 2;
            System.out.println("运行结果:"+i);
            return i;
        }
    }
}

main 开始
当前线程:1
运行结果:5
线程返回值5
main 结束

四、线程池

线程池可以控制服务器资源，保持服务器线程数量不至于服务器压力过大，性能稳定

public class ThreadTest {
    public static void main(String[] args) {
        System.out.println("main 开始");
        //线程池可以控制服务器资源，保持服务器线程数量不至于服务器压力过大
        ExecutorService executorService = Executors.newFixedThreadPool(20);
        Future<Integer> submit = executorService.submit(new Callable01());
        try {
        	//不get不会阻塞主线程
            Integer integer = submit.get();
            System.out.println("线程结果"+integer);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }
        System.out.println("main 结束");
    }

    public static class Callable01 implements Callable<Integer> {
        @Override
        public Integer call() {
            System.out.println("当前线程:"+Thread.currentThread( ).getId());
            int i = 10 / 2;
            System.out.println("运行结果:"+i);
            return i;
        }
    }
}

main 开始
当前线程:12
运行结果:5
线程结果5
main 结束

总结

	Thread	Runnable	Callable+FutureTask	线程池
返回值	N	N	Y	Y
资源控制	N	N	N	Y