【学习】线程池：线程池提交任务的方式execute与submit的区别

这三种线程池的方式有风险

FixedThreadPool（固定大小的线程池）

• 核心线程和最大线程一样，这样空闲线程就不会被销毁
• 允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。

SingleThreadExecutor（单个线程的线程池）

• 核心线程数和最大线程数都为1，说明全是核心线程
• 允许的请求队列长度为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。
  

CachedThreadPool（可缓存的线程池）

• 核心线程数为0，最大线程数为Integer.MAX_VALUE，说明全是空闲线程，空闲线程存活时间为60秒。
• 允许的创建线程数量为Integer.MAX_VALUE，可能会堆积大量的请求，从而导致OOM。
  

execute与submit的区别

execute代码案例

• 首先创建任务类

/**
 * @Description 任务
 * @ClassName
 * @Author 
 * @Date 2022/2/6 20:56
 **/
public class Task implements Runnable{

    public void run() {
        System.out.println(Thread.currentThread().getName());
    }
}

• 单个线程池执行任务

import com.naidou.threadPool.tp02.Task;

import java.util.concurrent.*;

/**
 * @Description  execute与submit的区别
 * @ClassName ThreadPool03
 * @Date 2022/2/9 21:12
 **/
public class ThreadPool03 {


    public static void main(String[] args) {
        // 创建任务
        Runnable task = new Task();
        // 创建单个线程池
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        // 提交任务
        testExecute(task,threadPool);
    }
    private static void testExecute(Runnable task,ExecutorService threadPool){
        // 提交任务
        threadPool.execute(task);
        // 关闭线程池
        threadPool.shutdown();
    }
 }

• 输出结果

submit所包含三种方法

Future所包含方法

submit(Runable，Future<?>)代码案例

import com.naidou.threadPool.tp02.Task;

import java.util.concurrent.*;

/**
 * @Description  execute与submit的区别
 * @ClassName ThreadPool03
 * @Date 2022/2/9 21:12
 **/
public class ThreadPool03 {


    public static void main(String[] args) {
        // 创建任务
        Runnable task = new Task();
        // 创建单个线程池
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        // 提交任务
        testSubmit(task,threadPool);
    }
    /**
     * @Description submit不确定的类型
     * @param task
     * @param threadPool
     * @Date 2022/2/9 20:37
     * @Return
     **/
    private static void testSubmit(Runnable task,ExecutorService threadPool){
        Future<?> future = threadPool.submit(task);
        try {
            Object result = future.get();
            System.out.println(result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } finally {
            // 关闭线程池
            threadPool.shutdown();
        }
    }
 }

• 输出结果
  

submit(Runable，Future)代码案例

import com.naidou.threadPool.tp02.Task;

import java.util.concurrent.*;

/**
 * @Description  execute与submit的区别
 * @ClassName ThreadPool03
 * @Date 2022/2/9 21:12
 **/
public class ThreadPool03 {


    public static void main(String[] args) {
        // 创建任务
        Runnable task = new Task();
        // 创建单个线程池
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        // 提交任务
        testSubmitT(task,threadPool);
    }

    /**
     * @Description submit确定的类型
     * @param task
     * @param threadPool
     * @Date 2022/2/9 20:37
     * @Return
     **/
    private static void testSubmitT(Runnable task,ExecutorService threadPool){
        Future<String> future = threadPool.submit(task,"任务完成");
        try {
            String result = future.get();
            System.out.println(result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } finally {
            // 关闭线程池
            threadPool.shutdown();
        }
    }
 }

• 输出结果
  

submit(Callable，Future)代码案例

首先创建任务类实现Callable

import java.util.concurrent.Callable;

/**
 * @Description Callable任务
 * @ClassName ResultTask
 * @Date 2022/2/9 20:39
 **/
public class ResultTask implements Callable<Integer> {

    public Integer call() throws Exception {
        return 1+1;
    }
}

线程池执行任务

import com.naidou.threadPool.tp02.Task;

import java.util.concurrent.*;

/**
 * @Description  execute与submit的区别
 * @ClassName ThreadPool03
 * @Date 2022/2/9 21:12
 **/
public class ThreadPool03 {


    public static void main(String[] args) {
        // 创建任务
        ResultTask task1 = new ResultTask();
        // 创建单个线程池
        ExecutorService threadPool = Executors.newSingleThreadExecutor();
        // 提交任务
        testSubmitCallable(task1,threadPool);

    }

    /**
     * @Description submit  Callable确定的类型
     * @param task
     * @param threadPool
     * @Date 2022/2/9 20:37
     * @Return
     **/
    private static void testSubmitCallable(ResultTask task,ExecutorService threadPool){
        Future<Integer> future = threadPool.submit(task);
        try {
            Integer result = future.get();
            System.out.println(result);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        } finally {
            // 关闭线程池
            threadPool.shutdown();
        }
    }
}

• 输出结果
  

总结二者区别

参考地址

线程池视频讲解03，04