Java新建一个子线程异步运行方法

如何在运行主方法的同时异步运行另一个方法，我是用来更新缓存；
1. 工具类

1. public class ThreadPoolUtils {
2.     private static final Logger LOGGER = LoggerFactory.getLogger(ThreadPoolUtils.class);
3.     private static final String POOL_NAME = "thread-im-runner";
4.     // 等待队列长度
5.     private static final int BLOCKING_QUEUE_LENGTH = 20000;
6.     // 闲置线程存活时间
7.     private static final int KEEP_ALIVE_TIME = 5 * 1000;
8.     private static ThreadPoolExecutor threadPool = null;
10.     private ThreadPoolUtils() {
11.         throw new IllegalStateException("utility class");
12.     }
14.     /**
15.      * 无返回值直接执行
16.      *
17.      * @param runnable 需要运行的任务
18.      */
19.     public static void execute(Runnable runnable) {
20.         getThreadPool().execute(runnable);
21.     }
23.     /**
24.      * 有返回值执行 主线程中使用Future.get()获取返回值时，会阻塞主线程，直到任务执行完毕
25.      *
26.      * @param callable 需要运行的任务
27.      */
28.     public static <T> Future<T> submit(Callable<T> callable) {
29.         return getThreadPool().submit(callable);
30.     }
32.     private static synchronized ThreadPoolExecutor getThreadPool() {
33.         if (threadPool == null) {
34.             // 核心线程数、最大线程数、闲置线程存活时间、时间单位、线程队列、线程工厂、当前线程数已经超过最大线程数时的异常处理策略
35.             threadPool = new ThreadPoolExecutor(50, 500, KEEP_ALIVE_TIME, TimeUnit.MILLISECONDS,
36.                 new ArrayBlockingQueue<>(BLOCKING_QUEUE_LENGTH),
37.                 new ThreadFactoryBuilder().setNameFormat(POOL_NAME + "-%d").build(),
38.                 new ThreadPoolExecutor.AbortPolicy() {
39.                     @Override
40.                     public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
41.                         LOGGER.warn("线程过多，当前运行线程总数：{}，活动线程数：{}。等待队列已满，等待运行任务数：{}", e.getPoolSize(), e.getActiveCount(),
42.                             e.getQueue().size());
43.                     }
44.                 });
45.         }
46.         return threadPool;
47.     }
49.     private static synchronized ThreadPoolExecutor getThreadPoolByCpuNum() {
50.         if (threadPool == null) {
51.             // 获取处理器数量
52.             int cpuNum = Runtime.getRuntime().availableProcessors();
53.             // 根据cpu数量,计算出合理的线程并发数
54.             int maximumPoolSize = cpuNum * 2 + 1;
55.             // 核心线程数、最大线程数、闲置线程存活时间、时间单位、线程队列、线程工厂、当前线程数已经超过最大线程数时的异常处理策略
56.             threadPool = new ThreadPoolExecutor(maximumPoolSize - 1, maximumPoolSize, KEEP_ALIVE_TIME,
57.                 TimeUnit.MILLISECONDS, new ArrayBlockingQueue<>(BLOCKING_QUEUE_LENGTH),
58.                 new ThreadFactoryBuilder().setNameFormat(POOL_NAME + "-%d").build(),
59.                 new ThreadPoolExecutor.AbortPolicy() {
60.                     @Override
61.                     public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {
62.                         LOGGER.warn("线程爆炸了，当前运行线程总数：{}，活动线程数：{}。等待队列已满，等待运行任务数：{}", e.getPoolSize(), e.getActiveCount(),
63.                             e.getQueue().size());
64.                     }
65.                 });
66.         }
67.         return threadPool;
68.     }
69. }

复制代码

2.实际使用

1.     ThreadPoolUtils.execute(() -> {
2.             this.Method();
3.         });

复制代码

 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！