JavaEE：代码简单优化

一、使用对象池：

说明：
复用对象，降低频繁创建/回收对象的性能损耗。

1.自定义简单对象池：

public class ObjectPool<T> {//自定义简单对象池
    private static ObjectPool mInstance;
    private final int Default_SIZE = 100;
    private int mMaxSize = Default_SIZE; //对象最大个数
    private static final String LOCK = "ObjectPool";
    //活跃对象
    private Set<T> mActiveObjs = Collections.synchronizedSet(new HashSet<>());
    //闲置对象
    private Set<T> mIdleObjs = Collections.synchronizedSet(new HashSet<>());
    private ObjectPool(int maxSize) {
        if (maxSize > 0) mMaxSize = maxSize;
    }
    public static ObjectPool I() {
        return I(-1);
    }
    public static ObjectPool I(int maxSize) {
        synchronized (LOCK) {
            if (mInstance == null) mInstance = new ObjectPool(maxSize);
            return mInstance;
        }
    }
    public synchronized T obtain(Class<T> clazz) throws Exception {//获取对象
        T obj;
        if (!mIdleObjs.isEmpty()) {//从对象池拿对象
            obj = mIdleObjs.iterator().next();
            mIdleObjs.remove(obj);
            mActiveObjs.add(obj);
            return obj;
        }
        if ((mActiveObjs.size() + mIdleObjs.size()) <= mMaxSize) {//创建新对象并存入池中
            obj = (T) clazz.getMethod("init").invoke(clazz);
            mActiveObjs.add(obj);
            return obj;
        }
        try {//阻塞线程
            synchronized (LOCK) {
                LOCK.wait();
            }
        } catch (Exception e) {
            throw new Exception("获取对象异常");
        }
        return obtain(clazz);
    }
    public synchronized void Obj(T obj) throws Exception {归还对象
        if (obj == null) return;
        try {//归还对象并唤醒其他等待中的线程
            mActiveObjs.remove(obj);
            mIdleObjs.add(obj);
            synchronized (LOCK) {
                LOCK.notify();
            }
        } catch (Exception e) {
            throw new Exception("归还对象异常");
        }
    }
}

2.Commons-Pool2对象池：

(1)API说明：

ObjectPool分类：

GenericObjectPool/GenericKeyedObjectPool：通用对象池
BaseObjectPool：抽象类，用于自定义对象池
ErodingObjectPool/ErodingKeyedObjectPool：归还对象后，对象被丢弃
ProxiedObjectPool/ProxiedKeyedObjectPool：代理对象池，获取代理对象
SoftReferenceObjectPool：软引用对象池
SynchronizedObjectPool/SynchronizedKeyedObjectPool：线程安全对象池

ObjectPool方法：

borrowObject：获取对象
returnObject：归还对象
invalidateObject：丢弃对象
addObject：增加空闲对象
clear：清空所有空闲对象
close：释放对象池
getNumActive：获取活动对象个数
getNumIdle：获取空闲对象个数

PooledObject分类：

DeffaultPooledObject：包装对象，监控对象创建/使用时间、状态等
PooledSoftReference：基于DeffaultPooledObject，配合SoftReferenceObjectPool使用

PooledObject状态：

IDLE：空闲对象
ALLOCATED：活跃对象
EVICTION：对象在驱逐测试
EVICTION_RETURN_TO_HEAD：驱逐测试成功，对象移到队列顶部
VALIDATION：空闲对象校验中
VALIDATION_PREALLOCATED：(池外)对象获取时校验中
VALIDATION_RETURN_TO_HEAD：(池外)对象校验成功后移到队列顶部
ABANDONED：(池内)对象放逐中，将会变成INVALID
INVALID：对象失效/驱逐测试失败/校验失败/销毁
RETURNING：对象归还中

GenericObjectPoolConfig配置：

softMinEvictableIdleTimeMillis：同minEvictableIdleTimeMillis，默认-1
testOnBorrow：出借前有效性测试，默认false
testOnCreate：创建后有效性测试，默认false
testOnReturn：归还前有效性测试，默认false
testWhileIdle：空闲有效性测试(timeBetweenEvictionRunsMillis>0生效)，默认false
timeBetweenEvictionRunsMillis：定时器周期，值>0时创建定时器，默认-1

GenericObjectPoolConfig配置(GenericObjectPool构造第2参数)：

setMaxTotal(8)：对象总数，默认8
setMaxIdle(8)：最大空闲对象数，默认8
setMinIdle(0)：最小空闲对象数，默认0
setLifo(true)：(默认)true对象池后进先出，false先进先出
setMaxWait(Duration.ofMillis(-1))：取对象阻塞时最大等待时间，默认-1无限时
setMinEvictableIdleTime(Duration.ofMillis(1800000L))：设置对象允许空闲的最小时间，默认1800000L
setNumTestsPerEvictionRun(3)：每次驱逐数量，默认3

AbandonedConfig配置(GenericObjectPool构造第3参数)：

setLogAbandoned(false)：true应用在废弃，默认false
setLogWriter(PrintWriter)：日志打印组件，默认System.out
setRemoveAbandonedOnBorrow(false)：true借用对象时移除废弃对象，默认false
setRemoveAbandonedOnMaintenance(false)：true当removeAbandonedTimeout时间到了后移除对象(timeBetweenEvictionRunsMillis>0生效)，默认false
setRemoveAbandonedTimeout(Duration.ofMinutes(5L))：废弃对象移除等待时间，默认5秒
setRequireFullStackTrace(true)：logAbandoned为true时输出完整栈信息，默认true
setUseUsageTracking(false)：记录并保留最新栈跟踪信息，默认false

Abandon与Evict区别：

Abandon：(池内)对象放逐中的状态
Evict：清理ABANDONED/INVALID状态对象的过程

(2)使用：

添加commons-pool2依赖：