线程池ThreadPool简单操作

初始化线程的 4 种方式

1、继承 Thread

2、实现 Runnable

3、实现 Callable 接口 + FutureTask（可以拿到返回结果，可以处理异常）

4、线程池，开发中不建议使用1、2、3种情况。

方式一和方式二 主进程无法获取线程的运算结果，不适合当前场景

方式三：主进程可以获取当前线程的运算结果，但是不利于控制服务器种的线程资源，可以导致服务器资源耗尽

方式四：1，2，3种方式都不能控制资源，所以开发中不建议使用，通过线程池比较好。

/**
 * @desc: 线程池案例
 */
public class ThreadTest {
    // 创建一个线程池(10线程)
    public static ExecutorService executorService = Executors.newFixedThreadPool(10);

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        System.out.println("main......start......");
        /**
         * 1、继承 Thread
         * 2、实现 Runnable
         * 3、实现 Callable 接口 + FutureTask（可以拿到返回结果，可以处理异常）
         * 4、线程池
         */

        // Thread
        Thread01 thread01 = new Thread01();
        // 启动线程
        thread01.start();

        // Runnable
        Runnable01 runnable01 = new Runnable01();
        new Thread(runnable01).start();

        // 实现 Callable 接口 + FutureTask
        FutureTask<Integer> futureTask = new FutureTask<>(new Callable01());
        new Thread(futureTask).start();
        // 实现阻塞状态，等待计算完成返回值后才打印
        Integer i = futureTask.get();

        System.out.println("main......end......" + i.toString());

        System.out.println("----------------以下为线程池执行------------------");

        System.out.println("线程池开始执行......start......");
        // 线程池执行 Runnable
        executorService.execute(new Runnable01());
        // 线程池执行 FutureTask
        FutureTask<Integer> integerFutureTask = new FutureTask<>(new Callable01());
        executorService.submit(integerFutureTask);
        Integer integer = integerFutureTask.get();

        System.out.println("线程池执行完毕......end......" + i.toString());
    }

    /**
     * 1、继承 Thread
     */
    public static class Thread01 extends Thread {
        @Override
        public void run() {
            System.out.println("Thread_ID：" + Thread.currentThread().getId());
            System.out.println("Thread_名称：" + Thread.currentThread().getName());
            int i = 1000 / 35;
            System.out.println("Thread_运行结果：" + i);
        }
    }

    /**
     * 2、实现 Runnable
     */
    public static class Runnable01 implements Runnable{
        @Override
        public void run() {
            System.out.println("Runnable_ID：" + Thread.currentThread().getId());
            System.out.println("Runnable_名称：" + Thread.currentThread().getName());
            int i = 1000 / 35;
            System.out.println("Runnable_运行结果：" + i);
        }
    }

    /**
     * 3、实现 Callable 接口
     */
    public static class Callable01 implements Callable<Integer>{

        @Override
        public Integer call() throws Exception {
            System.out.println("Callable_ID：" + Thread.currentThread().getId());
            System.out.println("Callable_名称：" + Thread.currentThread().getName());
            int i = 1000 / 35;
            System.out.println("Callable_运行结果：" + i);
            return i;
        }
    }
}