20220523_Java线程池创建方式三种

一.
ExecutorService pool = new ThreadPoolExecutor方式
不拿返回值的方法
Runnable任务类代码

public class MyRun implements Runnable {
    @Override
    public void run() {
        for (int i = 0; i < 5; i++) {
            System.out.println(Thread.currentThread().getName()+" is printing out ==> "+i);
        }
        try {
//            System.out.println(Thread.currentThread().getName()+" gonna sleep for 3 seconds");
            Thread.sleep(3000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

执行体

public class threadPoolDemo1 {
    public static void main(String[] args) {
        ExecutorService pool = new ThreadPoolExecutor(2,4,5, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(4),Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());

        Runnable mission = new MyRun();
        /**
         * 同一个任务可以同时交给多个线程跑
         */
        pool.execute(mission);//核心线程两个
        pool.execute(mission);
        pool.execute(mission);//排队线程四个
        pool.execute(mission);
        pool.execute(mission);
        pool.execute(mission);

        pool.execute(mission);//这里开始创建临时线程3，4
        pool.execute(mission);
        /**
         * 这里就开始报拒绝异常了RejectedExecutionException
         * 如果拒绝策略是ThreadPoolExecutor.CallerRunsPolicy()，就会让主线程执行*/
//        pool.execute(mission);

        /**如果线程睡眠，比如本例时各谁3秒，立刻关闭会报打断异常InterruptedException*/
//        pool.shutdownNow();
        /**这个关闭会等所有线程执行完毕之后再关，实际开发中基本不关闭线程池,我这里关*/
        pool.shutdown();

    }
}

要拿返回值的方法
Future f1 = pool.submit(new MyCall())方式
Callable类代码

public class MyCall implements Callable<String> {
    private int n;

    public MyCall(int n) {
        this.n = n;
    }

    @Override
    public String call() throws Exception {
        int sum = 0;
        for (int i = 1; i <=n; i++) {
            sum += i;
        }
        return Thread.currentThread().getName()+" calculated 1~"+n+", and it equals to: "+sum;
    }
}

执行体

public class ThreadPoolDemo2 {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        ExecutorService pool = new ThreadPoolExecutor(2,4,5, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(2), Executors.defaultThreadFactory(),new ThreadPoolExecutor.AbortPolicy());

        Future<String> f1 = pool.submit(new MyCall(100));
        Future<String> f2 = pool.submit(new MyCall(200));
        Future<String> f3 = pool.submit(new MyCall(300));
        Future<String> f4 = pool.submit(new MyCall(400));
        /**
         * 从这开始建临时线程
         * 池方法submit内的参数是一个Callable对象
         * 池方法的返回值是一个Future对象
         */
        Future<String> f5 = pool.submit(new MyCall(500));
        Future<String> f6 = pool.submit(new MyCall(600));

        /**Future对象里得到的返回内容要用get方法获得*/
        System.out.println(f1.get());
        System.out.println(f2.get());
        System.out.println(f3.get());
        System.out.println(f4.get());
        System.out.println(f5.get());
        System.out.println(f6.get());

        /**实际中不关闭，但我这里关闭线程池*/
        pool.shutdown();

    }
}

二.用Executors工具类创线程池

public class ExecutorsDemo1 {
    public static void main(String[] args) {
        /**用Executors工具类可以返回线程池ExecutorService，这方法内部还是new一个ThreadPoolExecutor
         * BlockingQueue参数没填，是max_value,就是无限*/
        ExecutorService pool = Executors.newFixedThreadPool(3);

        pool.execute(new MyRun());
        pool.execute(new MyRun());
        pool.execute(new MyRun());
        /**从这里开始线程池耗尽，因为线程运行够快，线程三以后仍然会执行，dan如果下面的线程无限增加，将导致OOM异常
         * 所以大型并发系统中不可能使用Executors工具类建立线程池*/
        pool.execute(new MyRun());

        pool.shutdown();//实际中不会关闭线程池，这里关
    }
}```