Java中对象池的本质是什么?(实战分析版)(下)

对象池相关配置项

对象池提供了许多配置项,在我们使用的GenericObjectPool默认基础对象池中可以通过构造方法传参传入GenericObjectPoolConfig,当然我们也可以看Gen算法的特征ericObjectPoolConfig底层实现的基础类BaseObjectPoolConfig,具体包算法导论含如下配置:

  • maxTotal算法分析的目的是f1a;对象池中最大使用数量,默认为8
  • maxIdle:对象中空闲对象最大数量,默认为8
  • minIdle:对象池中空闲对象最小数算法设计与分析量,默认为算法的空间复杂度是指8
  • lifo:java;当去获取对象池中的空闲实例时&#xjava培训ff0c;是否需要遵循后进先出的原则&算法导论#xff0cjava面试题;默java怎么读认为true
  • blockWhenExhausted:当对象池处于exhausted状态,即可用实例为空时,是否阻塞来获取实例的线程,默认 true
  • fairness:当对象池处于exhausted状态,算法的空间复杂度是指;即可用实例为空算法的五个特性时,大量线程在同时阻塞等待获取可用的实例,fairness配置来控制是否启用公平锁算法,即先到先javascript百炼成仙得&#xjava模拟器ff0c;默认为false。这一项的前提是blockWhenExhausted配置为true
  • maxWaitMillis:最大阻塞时间,当对象池处于exhausted状态,即可用实例为空时,大量线程在同时阻塞等待获取可用的实例,如果阻塞时间超过了maxWaitMillis将会抛出异常。当此值为负数javascript时,代表无限期阻塞直到可用。默认为-1
  • testOnCreate:创建对象前是否校验(即调算法的有穷性是指用工厂的validateObject()方法),如果检验失败,那算法的空间复杂度是指borrowObject()返回将失败,默认为false
  • testOnBorjavarjavaeeow:取用对象前是否检验,默认为false
  • testOnReturnjavascript百炼成仙f1a;返回对象池前是否检验,即调用工算法导论厂的javascriptreturnObject(),若检算法分析的目的是验失败会销毁对象而不是返回池中,默认为false
  • timeBetweenEvictjava环境变量配置ionRunsMillis:驱逐周期,默认为-1代表不进行驱逐测试
  • testWhjava语言ileIdle:处于idle队列中即闲置的对象是否被驱逐器进行驱逐验证,当该对象上次运行时间距当前超过了setTimeBetweenEvictionRunsMillis(long))设置的值,将会被驱逐验证,调用算法的五个特性validajavateObject()方法,若验证成功,对象将会算法的有穷性是指销毁。默认为false

使用步骤

  1. 创建工厂类:通过java环境变量配置继承BaseGenericObjectPool或者实现基础接口PooledObje算法的时间复杂度取决于ctFactory,并按照业务需求重javascript写对象的创建、销毁、校验、激活、钝化方法,其中销毁多为连接的关闭、置空等。
  2. 创建池:通过继承GenericObjectPool或者实现基础接口ObjectPool,建议使用前者,它为我们提供了空闲对象驱逐算法导论检测机制(即将空闲队列中长时间未使用的对象销毁,降低内存占用),以及提供了很多对象的基本信息,例如对象最后被使用的时间、使用对象算法分析的目的是前是否检验等。
  3. 创建池相关配置(可选):通过继承Generi算法的时间复杂度取决于cObjectPoolConfig或者继承BaseObje算法的时间复杂度取决于ctPoolConfig,来增加对线程池的配置控制,建议使用前者,它为我们实现了基本方法,只需要自己添加需要的属性即可。
  4. 创建包装类&#算法的五个特性xff08;可选):即要存在于对象池中的对象,在实际对象之外添加许多基础属性&java模拟器#xff0c;便于了解对象池中对象的实时状态。

注意事项

我们虽然使用了默认实现,但是也应该结合实际生产情况进行优化,不能使用了线程池java而性能却更java怎么读低了java语言。在使用中我们应注意以下事项:

  • 要为对象池设置空闲队列最大最小值,默认最大最小值,默认最大为8往往不算法的五个特性能满足需要
private volatile int maxIdle = GenericObjectPoolConfig.DEFAULT_MAX_IDLE;
private volatile int minIdle = GenericObjectPoolConfig.DEFAULT_MIN_IDLE;
public static final int DEFAULT_MAX_IDLE = 8;
public static final int DEFAULT_MIN_IDLE = 0;
  • 对象池设置maxWaitMillis属性&#java培训xff0c;即取用对象最大等待时间
  • 使用完对象及时释放对象&#x算法的五个特性ff0c;将对象返回池中,特别是发生了异常也要通过try..chatch..finalljava怎么读y的方式确保释放,避免占用资源

我们展开讲讲注意事项,首先为什么要算法的时间复杂度取决于设置maxWaitMillis,我们取用对象使用的如下方法

public T borrowObject() throws Exception {
    return borrowObject(getMaxWaitMillis());
}

可以看到默认的最大算法分析的目的是等待时间-1L

private volatile long maxWaitMillis =
        BaseObjectPoolConfig.DEFAULT_MAX_WAIT_MILLIS;
 //....
public static final long DEFAULT_MAX_WAIT_MILLIS = -1L;

我们java模拟器再来查看取用对象逻辑,blockWhejavaeenExhausted默认java模拟器为true,意思是当池中不存在空闲对象时,又来取用对象,线程将会被阻塞直到有新的可用对象。从上我们得知-1L将会执行idleObjects.takeFirst(算法的特征)

public T borrowObject(final long borrowMaxWaitMillis) throws Exception {
        //.......
        final boolean blockWhenExhausted = getBlockWhenExhausted();
        boolean create;
        final long waitTime = System.currentTimeMillis();
        while (p == null) {
          //.......
            if (blockWhenExhausted) {
                if (p == null) {
                    if (borrowMaxWaitMillis < 0) {
                        p = idleObjects.takeFirst();
                    } else {
                        p = idleObjects.pollFirst(borrowMaxWaitMillis,
                                TimeUnit.MILLISECONDS);
                    }
                }
            }
        }
}

如下javascript百炼成仙f0c;阻塞队列将会一直阻塞,直到有了空闲对象才停止阻塞,这样的设定将会在吞吐提高时造java怎么读成大面积阻塞影响

public E takeFirst() throws InterruptedException {
     lock.lock();
     try {
         E x;
         while ( (x = unlinkFirst()) == null) {
             notEmpty.await();
         }
         return x;
     } finally {
         lock.unlock();
     }
 }

还有一个注意事项就是要记得回收资源,即调用public void returnObject(final T obj)方法,原因显而易见算法的特征f0c;对象池对我们是否使用完了对象是无感知的,需要我们调用该方法回收对象,特别是发生异常也要保证回收&java#xff0c;因此最佳实践如下:

try{
   item = pool.borrowObject();
 } catch(Exception e) {
   log.error("....");
 } finally {
   pool.returnObject(item);
 }

实例使用

实例1:实现一个简单的字符串池

创建字符串工厂

package com.anqi.demo.demopool2.pool.fac;
import org.apache.commons.pool2.BasePooledObjectFactory;
import org.apache.commons.pool2.PooledObject;
import org.apache.commons.pool2.impl.DefaultPooledObject;
/**
 * 字符串池工厂
 */
public class StringPoolFac extends BasePooledObjectFactory<String> {
    public StringPoolFac() {
        super();
    }
    @Override
    public String create() throws Exception {
        return "str-val-";
    }
    @Override
    public PooledObject<String> wrap(String s) {
        return new DefaultPooledObject<>(s);
    }
    @Override
    public void destroyObject(PooledObject<String> p) throws Exception {
    }
    @Override
    public boolean validateObject(PooledObject<String> p) {
        return super.validateObject(p);
    }
    @Override
    public void activateObject(PooledObject<String> p) throws Exception {
        super.activateObject(p);
    }
    @Override
    public void passivateObject(PooledObject<String> p) throws Exception {
        super.passivateObject(p);
    }
}

创建字符串池

package com.anqi.demo.demopool2.pool;
import org.apache.commons.pool2.PooledObjectFactory;
import org.apache.commons.pool2.impl.GenericObjectPool;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
/**
 * 字符串池
 */
public class StringPool extends GenericObjectPool<String> {
    public StringPool(PooledObjectFactory<String> factory) {
        super(factory);
    }
    public StringPool(PooledObjectFactory<String> factory, GenericObjectPoolConfig<String> config) {
        super(factory, config);
    }
}

测试主类

首先我们我们设置setMaxTotal为2,即最多有两个对象被取出使用,设置

setMaxW算法设计与分析aitMillis为3S,即最多被阻塞3S,我们循环取用3次,并不释放资源

import com.anqi.demo.demopool2.pool.fac.StringPoolFac;
import org.apache.commons.pool2.impl.GenericObjectPoolConfig;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
public class StringPoolTest {
    private static final Logger LOG = LoggerFactory.getLogger(StringPoolTest.class);
    public static void main(String[] args) {
        StringPoolFac fac = new StringPoolFac();
        GenericObjectPoolConfig<String> config = new GenericObjectPoolConfig<>();
        config.setMaxTotal(2);
        config.setMinIdle(1);
        config.setMaxWaitMillis(3000);
        StringPool pool = new StringPool(fac, config);
        for (int i = 0; i < 3; i++) {
            String s = "";
            try {
                s = pool.borrowObject();
                LOG.info("str:{}", s);
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
//                if (!s.equals("")) {
//                    pool.returnObject(s);
//                }
            }
        }
    }
}

结果如下,在两次成功调用之后&#xjava语言ff0c;阻塞3S,接着程序报错停止。这是因为可用资源最多为2,若不释放将会无资源可用&java语言#xff0c;新来的调用者会被阻塞3S,之后报错取用失败。

16:18:42.499 [main] INFO com.anqi.demo.demopool2.pool.StringPoolTest - str:str-val-
16:18:42.505 [main] INFO com.anqi.demo.demopool2.pool.StringPoolTest - str:str-val-
java.util.NoSuchElementException: Timeout waiting for idle object

我们放开注释,算法工程师;释放资源后得到正常执行结果

16:20:52.384 [main] INFO com.anqi.demo.demopool2.pool.StringPoolTest - str:str-val-
16:20:52.388 [main] INFO com.anqi.demo.demopool2.pool.StringPoolTest - str:str-val-
16:20:52.388 [main] INFO com.anqi.demo.demopool2.pool.StringPoolTest - str:str-val-

全部javaee代码地址

https://github.算法com/Motianshi/alldemo/tree/master/djavaemo-pool2