java-concurrent
  • 前言
  • Java多线程基础
    • 线程简介
      • 什么是线程
      • 为什么要使用多线程/线程使用的好处
      • 线程的优先级
      • 线程的状态
      • Daemon线程
    • 启动和终止线程
      • 构造线程
      • 启动线程
      • 中断线程
      • 过期的suspend()、resume()和stop()
      • 安全地终止线程
    • 多线程实现方式
    • 多线程环境下,局部变量和全局变量都会共享吗?
    • Java线程间的协助和通信
      • Thread.join的使用
      • volatile、ThreadLocal、synchronized3个关键字区别
      • volatile关键字
      • ThreadLocal关键字
      • synchronized关键字
      • Java线程等待和通知的相关方法
    • 实战应用
      • 连接池
      • 线程池
      • 如何计算合适的线程数
  • Java线程池与框架
    • Executor 框架
    • 自定义线程池——ThreadPoolExecutor
    • 线程池工具类(单例模式)
    • 关闭线程池
    • 合理地配置线程池
    • 线程池的监控
    • RejectedExecutionException产生的原因
    • SpringBoot配置线程池工具类
    • FutureTask详解
    • CompletionService讲解
    • Future、FutureTask、CompletionService、CompletableFuture区别
  • Java内存模型
    • Java 内存模型的基础
      • 并发编程模型的两个关键问题
      • Java内存模型的抽象结构
      • 从源代码到指令序列的重排序
      • 并发编程模型的分类
    • 重排序
      • 数据依赖性
      • as-if-serial语义
      • 程序顺序规则
      • 重排序对多线程的影响
    • 顺序一致性
      • 数据竞争与顺序一致性
      • 顺序一致性内存模型
      • 同步程序的顺序一致性效果
      • 未同步程序的执行特性
    • volatile内存语义
      • volatile的特性
      • volatile写-读建立的happens-before关系
      • volatile写-读的内存语义
      • volatile内存语义的实现
      • JSR-133为什么要增强volatile的内存语义
    • 锁内存定义
      • 锁的释放-获取建立的happens-before关系
      • 锁的释放和获取的内存语义
      • 锁内存语义的实现
      • concurrent包的实现
    • final域内存语义
      • final域的重排序规则
      • 写final域的重排序规则
      • 读final域的重排序规则
      • final域为引用类型
      • 为什么final引用不能从构造函数内“溢出”
      • final语义在处理器中的实现
      • JSR-133为什么要增强final的语义
    • happens-before
    • 双重检查锁定与延迟初始化
      • 双重检查锁定的由来
      • 问题的根源
      • 基于volatile的解决方案
      • 基于类初始化的解决方案
    • Java内存模型综述
      • 处理器的内存模型
      • 各种内存模型之间的关系
      • JMM的内存可见性保证
      • JSR-133对旧内存模型的修补
  • HashMap实现原理
    • 讲解(一)
    • 讲解(二)
    • HashMap原理(面试篇)
    • HashMap原理(面试篇二)
  • ConcurrentHashMap的实现原理与使用
    • 为什么要使用ConcurrentHashMap
    • ConcurrentHashMap的结构
    • ConcurrentHashMap的初始化
    • 定位Segment
    • ConcurrentHashMap的操作
    • ConcurrentHashMap讲解(一)
  • Java中的阻塞队列
    • 什么是阻塞队列
    • Java里的阻塞队列
    • 阻塞队列的实现原理
  • Fork/Join框架
    • 什么是Fork/Join框架
    • 工作窃取算法
    • Fork/Join框架的设计
    • 使用Fork/Join框架
    • Fork/Join框架的异常处理
    • Fork/Join框架的实现原理
    • ForkJoinPool的commonPool相关参数配置
  • java.util.concurrent包讲解
    • 线程安全AtomicInteger的讲解
    • CompletableFuture讲解
      • CompletableFuture接口详解
      • CompletableFuture与parallelStream()性能差异
      • CompletableFuture接口详解2
  • Java线程安全
    • 性能与可伸缩性
    • 解决死锁
    • 死锁定义
    • 如何让多线程下的类安全
    • 类的线程安全性定义
    • 实战:实现一个线程安全的单例模式
  • Java常用并发开发工具和类的源码分析
    • CountDownLatch
    • CyclicBarrier
    • Semaphore
    • Exchange
    • ConcurrentHashMap
    • ConcurrentSkipListMap
    • HashMap
      • HashMap源码实现及分析
      • HashMap的一些面试题
    • List
  • Java中的锁
    • 基础知识
    • 番外篇
    • synchronized 是可重入锁吗?为什么?
    • 自旋锁
  • Java多线程的常见问题
    • 常见问题一
Powered by GitBook
On this page
  • 显示关闭掉线程池
  • 解决方案
  • 线程数量超过maximumPoolSize
  • 解决方案

Was this helpful?

  1. Java线程池与框架

RejectedExecutionException产生的原因

引发java.util.concurrent.RejectedExecutionException主要有两种原因:

  1. 线程池显示的调用了shutdown()之后,再向线程池提交任务的时候,如果你配置的拒绝策略是ThreadPoolExecutor.AbortPolicy的话,这个异常就被会抛出来。

  2. 当你的排队策略为有界队列,并且配置的拒绝策略是ThreadPoolExecutor.AbortPolicy,当线程池的线程数量已经达到了maximumPoolSize并且超过队列数量的时候,你再向它提交任务,就会抛出ThreadPoolExecutor.AbortPolicy异常。

显示关闭掉线程池

这一点很好理解。比如说,你向一个仓库去存放货物,一开始,仓库管理员把门给你打开了,你放了第一件商品到仓库里,但是当你放好出去后,有人把仓库门关了,那你下次再来存放物品时,你就会被拒绝。示例代码如下:

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  


public class TextExecutor {  
    public ExecutorService fixedExecutorService = Executors.newFixedThreadPool(5);  
    public ExecutorService cachedExecutorService = Executors.newCachedThreadPool();  
    public ExecutorService singleExecutorService = Executors.newSingleThreadExecutor();  

    public void testExecutorException() {  
        for (int i = 0; i < 10; i ++) {  
            fixedExecutorService.execute(new SayHelloRunnable());  
            fixedExecutorService.shutdown();  
        }  
    }  

    private class SayHelloRunnable implements Runnable {  

        @Override  
        public void run() {  
            try {  
                Thread.sleep(1000);  
            } catch (InterruptedException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            } finally {  
                System.out.println("hello world!");  
            }  

        }  
    }  

    public static void main(String[] args) {  
        TextExecutor testExecutor = new TextExecutor();  
        testExecutor.testExecutorException();  
    }  
}

解决方案

  1. 不要显示的调用shutdown方法,例如Android里,只有你在Destory方法里cancel掉AsyncTask,则线程池里没有活跃线程会自己回收自己。

  2. 调用线程池时,判断是否已经shutdown,通过API方法isShutDown方法判断,示例代码:

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  


public class TextExecutor {  
    public ExecutorService fixedExecutorService = Executors.newFixedThreadPool(5);  
    public ExecutorService cachedExecutorService = Executors.newCachedThreadPool();  
    public ExecutorService singleExecutorService = Executors.newSingleThreadExecutor();  

    public void testExecutorException() {  
        for (int i = 0; i < 10; i ++) {  
            // 增加isShutdown()判断  
            if (!fixedExecutorService.isShutdown()) {  
                fixedExecutorService.execute(new SayHelloRunnable());  
            }  
            fixedExecutorService.shutdown();  
        }  
    }  

    private class SayHelloRunnable implements Runnable {  

        @Override  
        public void run() {  
            try {  
                Thread.sleep(1000);  
            } catch (InterruptedException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            } finally {  
                System.out.println("hello world!");  
            }  

        }  
    }  

    public static void main(String[] args) {  
        TextExecutor testExecutor = new TextExecutor();  
        testExecutor.testExecutorException();  
    }  
}

线程数量超过maximumPoolSize

示例代码里使用了自定义的ExecutorService,可以复现这种问题:

import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.SynchronousQueue;  
import java.util.concurrent.ThreadPoolExecutor;  
import java.util.concurrent.TimeUnit;  


public class TextExecutor {  
    public ExecutorService fixedExecutorService = Executors.newFixedThreadPool(5);  
    public ExecutorService cachedExecutorService = Executors.newCachedThreadPool();  
    public ExecutorService singleExecutorService = Executors.newSingleThreadExecutor();  
    public ExecutorService customerExecutorService = new ThreadPoolExecutor(3, 5, 0, TimeUnit.MILLISECONDS, new SynchronousQueue<Runnable>());  

    public void testExecutorException() {  
        for (int i = 0; i < 10; i ++) {  
            // 增加isShutdown()判断  
            if (!fixedExecutorService.isShutdown()) {  
                fixedExecutorService.execute(new SayHelloRunnable());  
            }  
            fixedExecutorService.shutdown();  
        }  
    }  

    public void testCustomerExecutorException() {  
        for (int i = 0; i < 100; i ++) {  
            customerExecutorService.execute(new SayHelloRunnable());  
        }  
    }  

    private class SayHelloRunnable implements Runnable {  

        @Override  
        public void run() {  
            try {  
                Thread.sleep(1000);  
            } catch (InterruptedException e) {  
                // TODO Auto-generated catch block  
                e.printStackTrace();  
            } finally {  
                System.out.println("hello world!");  
            }  

        }  
    }  

    public static void main(String[] args) {  
        TextExecutor testExecutor = new TextExecutor();  
        testExecutor.testCustomerExecutorException();;  
    }  
}

解决方案

  1. 尽量调大maximumPoolSize,例如设置为Integer.MAX_VALUE

public ExecutorService customerExecutorService = new ThreadPoolExecutor(3, Integer.MAX_VALUE, 0, TimeUnit.MILLISECONDS, new SynchronousQueue<Runnable>());

2.使用其他排队策略,例如LinkedBlockingQueue

public ExecutorService customerExecutorService = new ThreadPoolExecutor(3, 5, 0, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());

总结:

  1. 控制提交的任务数量,即提交的任务数量不要超过它当前能处理的能力 (这里可以用生产者消费者的模式来解决)

  2. 同一个线程池,确保不要在shutdown()之后在执行任务

  3. 可以用LinkedBlockingQueue代替ArrayBlockingQueue,因为LinkedBlockingQueue可以设成无界的,但是需要注意,设成无界后最终可能发生OOM(内存溢出),

所以要保证第一二点。

Previous线程池的监控NextSpringBoot配置线程池工具类

Last updated 5 years ago

Was this helpful?