Java Code Example mons.pool2.impl.GenericObjectPoolConfig
Java Code Examples for mons.pool2.impl.GenericObjectPoolConfig
The following are top voted examples for showing how to use
mons.pool2.impl.GenericObjectPoolConfig. These examples are extracted from open source projects.
You can vote up the examples you like and your votes will be used in our system to product
more good examples.
+ Save this class to your library
public void preparePool() throws Exception {
GenericObjectPoolConfig config = new GenericObjectPoolConfig();
config.setMaxTotal(poolSize);
config.setBlockWhenExhausted(true);
config.setTestOnBorrow(true);
pool = new mons.pool2.impl.GenericObjectPool&&(
new MyPooledObjectFactory(), config);
private DataSource getDataSource() {
if (dataSource == null) {
String host = getConfigManager().get().getString(Keys.Db.SERVER);
int port = getConfigManager().get().getInt(Keys.Db.PORT);
String dbname = getConfigManager().get().getString(Keys.Db.DB_NAME);
String user = getConfigManager().get().getString(Keys.Db.USER);
String password = getConfigManager().get().getString(Keys.Db.PASSWORD);
Properties props = new Properties();
props.setProperty(&user&, user);
props.setProperty(&password&, password);
props.setProperty(&defaultTransactionIsolation&, &NONE&);
String url = &jdbc:mysql://& + host + &:& + port + &/& + dbname + &?tcpKeepAlive=true&;
GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
poolConfig.setMinIdle(getDbCnxPoolMin());
poolConfig.setMaxTotal(getDbCnxPoolMax());
ConnectionFactory connectionFactory = new DriverManagerConnectionFactory(url, props);
PoolableConnectionFactory poolableConnectionFactory = new PoolableConnectionFactory(connectionFactory, null);
GenericObjectPool&PoolableConnection& connectionPool = new GenericObjectPool&&(poolableConnectionFactory, poolConfig);
poolableConnectionFactory.setPool(connectionPool);
dataSource = new PoolingDataSource&&(connectionPool);
(&Starting wakeup datasource with maxTotal={}&, connectionPool.getMaxTotal());
return dataS
* Create a new connection pool
* @param redisConnectionProvider the connection provider
* @param maxActive max active connections
* @param maxIdle max idle connections
* @param maxWait max wait time (ms) for a connection
public RedisConnectionPool(RedisConnectionProvider&T& redisConnectionProvider, int maxActive, int maxIdle, long maxWait) {
this.redisConnectionProvider = redisConnectionP
GenericObjectPoolConfig config = new GenericObjectPoolConfig();
config.setMaxIdle(maxIdle);
config.setMaxTotal(maxActive);
config.setMaxWaitMillis(maxWait);
config.setTestOnBorrow(true);
objectPool = new GenericObjectPool&T&(createFactory(redisConnectionProvider), config);
* init the JedisPoolObjectFactory and ObjectPool
@PostConstruct
public void init() {
GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
// maxIdle?????sop???pool size????????????????????redis??
if (this.maxIdle &= 0) {
poolConfig.setMaxIdle(this.maxIdle);
poolConfig.setMaxWaitMillis(this.maxWait);
poolConfig.setTestOnBorrow(testOnBorrow);
poolConfig.setMinIdle(minIdle);
poolConfig.setMaxTotal(maxActive);
poolConfig.setTestOnReturn(testOnReturn);
poolConfig.setTestWhileIdle(testWhileIdle);
poolConfig.setTimeBetweenEvictionRunsMillis(timeBetweenEvictionRunsMillis);
poolConfig.setNumTestsPerEvictionRun(numTestsPerEvictionRun);
poolConfig.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
poolConfig.setSoftMinEvictableIdleTimeMillis(softMinEvictableIdleTimeMillis);
poolConfig.setLifo(lifo);
jedisPool = new JedisPool(poolConfig, redisServer, port, timeout,
redisAuthKey);
protected void setUp() throws Exception {
// configuring the log-system (e.g. log4j)
TestUtils.configureLogging();
this.tmpDir = new TmpDirectory(&howllogger&);
// clears all existing file in dem tmp directory
this.tmpDir.clear();
GenericObjectPoolConfig cfg = new GenericObjectPoolConfig();
cfg.setMaxTotal(CONNECTION_POOL_SIZE);
this.factory = new PooledPhynixxManagedConnectionFactory(new TestConnectionFactory(), cfg);
this.factory.setSynchronizeConnection(true);
IDataLoggerFactory loggerFactory = new FileChannelDataLoggerFactory(&pool&, this.tmpDir.getDirectory());
LoggerPerTransactionStrategy strategy = new LoggerPerTransactionStrategy(loggerFactory);
this.factory.setLoggerSystemStrategy(strategy);
public void prepare(Map conf, TopologyContext context,
OutputCollector collector) {
this.collector =
GenericObjectPoolConfig pconf = new GenericObjectPoolConfig();
pconf.setMaxWaitMillis(2000);
pconf.setMaxTotal(1000);
pconf.setTestOnBorrow(false);
pconf.setTestOnReturn(false);
pconf.setTestWhileIdle(true);
pconf.setMinEvictableIdleTimeMillis(120000);
pconf.setTimeBetweenEvictionRunsMillis(60000);
pconf.setNumTestsPerEvictionRun(-1);
pool = new JedisPool(pconf, redisHost, redisPort, timeout);
public KyroFactory(final int maxTotal, final int minIdle, final long maxWaitMillis, final long minEvictableIdleTimeMillis) {
kryoPool = new GenericObjectPool&&(new PooledKryoFactory());
GenericObjectPoolConfig config = new GenericObjectPoolConfig();
config.setMaxTotal(maxTotal);
config.setMinIdle(minIdle);
config.setMaxWaitMillis(maxWaitMillis);
config.setMinEvictableIdleTimeMillis(minEvictableIdleTimeMillis);
kryoPool.setConfig(config);
private BaseObjectPoolConfig createSocketConnectionPoolConfig() {
final GenericObjectPoolConfig socketConnectionPoolConfig = new GenericObjectPoolConfig();
socketConnectionPoolConfig.setMaxTotal(this.clientBuildingConfig_
.getHostConnectionLimit());
if (this.clientBuildingConfig_.getHostConnectionCoreSize() & 0)
socketConnectionPoolConfig.setMinIdle(this.clientBuildingConfig_
.getHostConnectionCoreSize());
if (this.clientBuildingConfig_.getHostConnectionMaxIdle() & 0)
socketConnectionPoolConfig.setMaxIdle(this.clientBuildingConfig_
.getHostConnectionMaxIdle());
socketConnectionPoolConfig.setMaxWaitMillis(this.clientBuildingConfig_
.getMaxWaitHostConnectionMillis());
socketConnectionPoolConfig.setNumTestsPerEvictionRun(Integer.MAX_VALUE);
socketConnectionPoolConfig.setMinEvictableIdleTimeMillis(this.clientBuildingConfig_
.getHostConnectionMinIdle());
socketConnectionPoolConfig.setTimeBetweenEvictionRunsMillis(1 * 60000L);
return socketConnectionPoolC
private void readConfiguration() {
poolConfig = new GenericObjectPoolConfig();
// config the pool size for commons-pool
poolConfig.setMaxTotal(conf.getInt(ClientConfig.SENTRY_POOL_MAX_TOTAL, ClientConfig.SENTRY_POOL_MAX_TOTAL_DEFAULT));
poolConfig.setMinIdle(conf.getInt(ClientConfig.SENTRY_POOL_MIN_IDLE, ClientConfig.SENTRY_POOL_MIN_IDLE_DEFAULT));
poolConfig.setMaxIdle(conf.getInt(ClientConfig.SENTRY_POOL_MAX_IDLE, ClientConfig.SENTRY_POOL_MAX_IDLE_DEFAULT));
// get the retry number for reconnecting service
connectionRetryTotal = conf.getInt(ClientConfig.SENTRY_POOL_RETRY_TOTAL,
ClientConfig.SENTRY_POOL_RETRY_TOTAL_DEFAULT);
Example 10
private static void setupDataSource(String url, String user, String password) {
PoolableConnectionFactory factory = new PoolableConnectionFactory(
new DriverManagerConnectionFactory(url, user, password), null);
GenericObjectPoolConfig config = new GenericObjectPoolConfig();
config.setMaxTotal(maxIdle);
config.setMaxIdle(maxIdle);
config.setMinIdle(minIdle);
ObjectPool&PoolableConnection& connectionPool = new GenericObjectPool&&(factory, config);
factory.setPool(connectionPool);
dataSource = new PoolingDataSource&&(connectionPool);
Example 11
* ??? ??? ??? ?? ??? ??? ?? ???. ??? ????? ???? ??? ? ??.
private JedisHelper() {
GenericObjectPoolConfig config = new GenericObjectPoolConfig();
config.setMaxTotal(20);
config.setBlockWhenExhausted(true);
this.pool = new JedisPool(config, REDIS_HOST, REDIS_PORT);
Example 12
private HBaseConnectionManager() {
this.config = CloudGraphContext.instance().getConfig();
int min = this.config.getInt(CONNECTION_POOL_MIN_SIZE, 1);
int max = this.config.getInt(CONNECTION_POOL_MAX_SIZE, 20);
GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();
poolConfig.setMinIdle(min);
poolConfig.setMaxTotal(max);
PooledConnectionFactory factory = new PooledConnectionFactory(this.config);
this.pool = new GenericObjectPool&Connection&(factory, poolConfig);
factory.setPool(pool);
Example 13
public static HttpClientManager buildHttpClientManager() {
// Use -Daxibase.tsd.api.client.properties=&filename& to change default properties file name
ClientConfigurationFactory configurationFactory = ClientConfigurationFactory.createInstance();
ClientConfiguration clientConfiguration = configurationFactory.createClientConfiguration();
HttpClientManager httpClientManager = new HttpClientManager();
httpClientManager.setClientConfiguration(clientConfiguration);
GenericObjectPoolConfig objectPoolConfig = new GenericObjectPoolConfig();
objectPoolConfig.setMaxTotal(100);
objectPoolConfig.setMaxIdle(100);
httpClientManager.setObjectPoolConfig(objectPoolConfig);
httpClientManager.setBorrowMaxWaitMillis(10000);
return httpClientM
Example 14
* @return a GenericObjectPoolConfig configured with: maxActive=-1,
* maxIdle=10, minIdle=1, testOnBorrow=true,
* blockWhenExhausted=false
public static GenericObjectPoolConfig getDefaultPoolConfig() {
final GenericObjectPoolConfig cfg = new GenericObjectPoolConfig();
cfg.setMaxTotal(-1); // Infinite
cfg.setMaxIdle(10);
cfg.setMinIdle(1);
cfg.setTestOnBorrow(true);
cfg.setBlockWhenExhausted(false);
Example 15
private static &T& ObjectPool&T& createObjectPool(final PooledObjectFactory&T& factory) {
final GenericObjectPoolConfig objectPoolConfig = new GenericObjectPoolConfig();
objectPoolConfig.setMinEvictableIdleTimeMillis(TimeUnit.HOURS.toMillis(1)); // arbitrary, but positive so objects do get evicted
objectPoolConfig.setTimeBetweenEvictionRunsMillis(TimeUnit.MINUTES.toMillis(10)); // arbitrary, but positive so objects do get evicted
objectPoolConfig.setJmxEnabled(false);
objectPoolConfig.setBlockWhenExhausted(false);
objectPoolConfig.setMaxTotal(-1); // uncapped number of objects in the pool
final AbandonedConfig abandonedConfig = new AbandonedConfig();
abandonedConfig.setRemoveAbandonedOnBorrow(true);
abandonedConfig.setRemoveAbandonedTimeout((int) TimeUnit.MINUTES.toSeconds(30));
return new GenericObjectPool&T&(factory, objectPoolConfig, abandonedConfig);
Example 16
public void start() {
super.start();
GenericObjectPoolConfig config = new GenericObjectPoolConfig();
config.setTestOnBorrow(true);
pool = new JedisPool(config, host, port, timeout, password, database);
Example 17
protected void init(BasePooledObjectFactory&T& factory) {
GenericObjectPoolConfig config = new GenericObjectPoolConfig();
config.setMinIdle(apiConfig.getClientPoolSize());
config.setTestOnBorrow(true);
config.setTestOnReturn(true);
this.pool = PoolUtils.erodingPool(new GenericObjectPool&&(factory,
Example 18
* ?? Twemproxy ?&????????????&???
* ???????? Keys ?&???&??????????Key??????????????
* @throws IOException
public void checkSharding() throws IOException {
// ????? Key
File file = new File(TWEMPROXY_FILE);
List&String& keys = FileUtils.readLines(file);
* 1. ?? redis ?????? 2. ??? redis ??????? Key GET ?????????
List&HostAndPort& hostList = this.getHostList(ServerFlag.REDIS);
for (HostAndPort hostInfo : hostList) {
List&JedisShardInfo& shards = new ArrayList&JedisShardInfo&(1);
JedisShardInfo shardInfo = new JedisShardInfo(hostInfo.getHost(),
hostInfo.getPort(), DEFAULT_TIMEOUT);
shards.add(shardInfo);
GenericObjectPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxTotal(10);
poolConfig.setMaxIdle(10);
poolConfig.setMinIdle(3);
poolConfig.setMaxWaitMillis(TimeUnit.SECONDS.toMillis(1L));
poolConfig.setTestOnBorrow(true);
ShardedJedisPool jedisPool = new ShardedJedisPool(poolConfig,
ShardedJedis jedis = jedisPool.getResource();
int hits = 0;
for (String key : keys) {
String value = jedis.get(key);
if (!StringUtils.isEmpty(value)) {
jedis.del(key);
if (logger.isInfoEnabled()) {
(&Host {}'s hit ratio: {}&, hostInfo, hits);
} finally {
jedisPool.close();25046人阅读
Java（157）
前面两篇文章说了怎么样简单的使用commons-pool库，这里需要考虑一个问题就是在很多时候我们在池里的对象都是比较重型的并且大多数比较稀缺的资源，比如说数据库连接，这样如果一直把一些连接放在池里不归还，就会很占资源，并且是这些资源利用率降低，那么怎样才能更好的管理池子中的资源呢，commons-pool里提供了一个GenericObjectPool类，它的出现使上面的问题就迎刃而解了。同样对于GenericObjectPool类，也就有一个对应的GenericKeyedObjectPool类。下面还是例子说话一个Connection类，可以想象成一个远程连接比如数据库连接等。其中包括创建连接，关闭连接，和一个print方法。package com.mons.pool.sample3;
import org.slf4j.L
import org.slf4j.LoggerF
public class MyConnection {
private static Logger logger = LoggerFactory.getLogger(MyConnection.class);
public MyConnection(String name) {
this.name =
public void connect() {
this.connected =
(name + &: & + connected);
public void close() {
this.connected =
(name + &: & + connected);
public boolean isConnected() {
return this.
public String getName() {
return this.
public void print() {
(this.name);
}一个PoolableObjectFactory接口的实现类，提供makeObject, activateObject, passivateObject, validateObject, destroyObject方法。package com.mons.pool.sample3;
import mons.pool.PoolableObjectF
import org.slf4j.L
import org.slf4j.LoggerF
public class MyConnectionPoolableObjectFactory implements PoolableObjectFactory {
private static Logger logger = LoggerFactory.getLogger(MyConnectionPoolableObjectFactory.class);
private static int count = 0;
public Object makeObject() throws Exception {
MyConnection myConn = new MyConnection(generateName());
(myConn.getName());
myConn.connect();
return myC
public void activateObject(Object obj) throws Exception {
MyConnection myConn = (MyConnection)
(myConn.getName());
public void passivateObject(Object obj) throws Exception {
MyConnection myConn = (MyConnection)
(myConn.getName());
public boolean validateObject(Object obj) {
MyConnection myConn = (MyConnection)
(myConn.getName());
return myConn.isConnected();
public void destroyObject(Object obj) throws Exception {
MyConnection myConn = (MyConnection)
(myConn.getName());
myConn.close();
private synchronized String generateName() {
return &conn_& + (++count);
}一个测试类package com.mons.pool.sample3;
import mons.pool.ObjectP
import mons.pool.PoolableObjectF
import mons.pool.impl.GenericObjectP
import org.slf4j.L
import org.slf4j.LoggerF
public class Test {
private static Logger logger = LoggerFactory.getLogger(Test.class);
public static void main(String[] args) {
//test1();
//test2();
//test3();
private static void test1() {
PoolableObjectFactory factory = new MyConnectionPoolableObjectFactory();
GenericObjectPool.Config config = new GenericObjectPool.Config();
config.lifo =
config.maxActive = 5;
config.maxIdle = 5;
config.minIdle = 1;
config.maxWait = 5 * 1000;
ObjectPool pool = new GenericObjectPool(factory, config);
for (int i = 0; i & 10; i++) {
Thread thread = new Thread(new MyTask(pool));
thread.start();
//closePool(pool);
private static void test2() {
PoolableObjectFactory factory = new MyConnectionPoolableObjectFactory();
GenericObjectPool.Config config = new GenericObjectPool.Config();
config.lifo =
config.maxActive = 5;
config.maxIdle = 5;
config.minIdle = 1;
config.maxWait = 20 * 1000;
ObjectPool pool = new GenericObjectPool(factory, config);
for (int i = 0; i & 10; i++) {
Thread thread = new Thread(new MyTask(pool));
thread.start();
//closePool(pool);
private static void test3() {
PoolableObjectFactory factory = new MyConnectionPoolableObjectFactory();
GenericObjectPool.Config config = new GenericObjectPool.Config();
config.lifo =
config.maxActive = 5;
config.maxIdle = 0;
config.minIdle = 0;
config.maxWait = -1;
ObjectPool pool = new GenericObjectPool(factory, config);
Thread thread = new Thread(new MyTask(pool));
thread.start();
Thread.sleep(60L * 1000L);
} catch (Exception e) {
e.printStackTrace();
//closePool(pool);
private static void closePool(ObjectPool pool) {
pool.close();
} catch (Exception e) {
e.printStackTrace();
private static class MyTask implements Runnable {
private ObjectP
public MyTask(ObjectPool pool) {
this.pool =
public void run() {
MyConnection myConn =
myConn = (MyConnection)pool.borrowObject();
myConn.print();
} catch(Exception ex) {
pool.invalidateObject(myConn);
Thread.sleep(10L * 1000L);
} catch(Exception ex) {
logger.error(&Cannot borrow connection from pool.&, ex);
} finally {
if (myConn != null) {
pool.returnObject(myConn);
} catch (Exception ex) {
logger.error(&Cannot return connection from pool.&, ex);
}其中包含了三个方法，分别测试了三种情况；类中包含了一个实现了Runnable接口的内部类，目的是为了启动几个线程来模拟的对连接类的使用，并且为了尽可能的真实，在run方法里sleep了10秒中；首先运行测试方法test1()可以看到，在循环10个线程申请Connection类时，前面5个可以很好的获取，但是后面5个线程就不能获取连接，并且抛出了异常，这是由于“config.maxActive = 5;”和“config.maxWait = 5 * 1000;”在起作用，由于配置了最大活动连接是5个，并且后续申请没有有效连接的等待时间是5秒，所以test1方法中后面五个线程在等了5秒后全部抛出异常，表明不能申请连接了。下面运行test2()方法，在test2中把“config.maxWait = 20 * 1000;”改成了20秒，而我们程序中每个线程使用连接会用去10秒，所以后面五个线程在等待了10秒后就全部获取连接了，所以程序最后会运行成功。再看test3()方法，其中把maxIdle和minIdle都改为0，就是在连接不用时立即真正归还连接，对于数据库连接来说就是关闭物理连接，而maxWait改为-1，就是如果没有申请到连接就永远等待，运行test3()方法，观察日志，可以看出程序在用户连接对象以后，会调用MyConnectionPoolableObjectFactory.destroyObject()和MyConnection.close()方法来销毁对象。所以如果是使用这样的配置，就相当于每次都是物理连接，用完后就关闭连接。当然这里是一个极端的例子，真实情况下不会把maxIdle和minIdle都设为0的。其实对于GenericObjectPool.Config类和GenericKeyedObjectPool.Config类还是有很多配置参数的，这里只是列出的最简单的几个常用的，具体可以参考官方文档。
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：2595358次
积分：26992
积分：26992
排名：第209名
原创：467篇
转载：29篇
评论：435条
阅读：13953
阅读：134666
阅读：179796
阅读：264404
(2)(2)(6)(12)(5)(8)(1)(1)(3)(1)(7)(9)(8)(3)(8)(8)(6)(6)(5)(11)(5)(4)(4)(7)(3)(5)(5)(11)(16)(6)(12)(4)(8)(3)(3)(4)(2)(3)(2)(5)(2)(3)(5)(8)(3)(6)(11)(5)(9)(5)(6)(10)(6)(6)(2)(3)(4)(9)(3)(4)(7)(6)(5)(6)(7)(11)(12)(10)(5)(5)(7)(2)(10)(4)(8)(1)(1)(2)(1)(2)(2)(3)(4)(1)(4)(1)(1)(1)(4)(3)(2)(2)(1)(2)(3)(2)(2)(3)(9)6273人阅读
今天用redis做mybatis的二级缓存，总是报下面这个错误。
Caused by: java.lang.ClassNotFoundException: org.apache.commons.pool2.impl.GenericObjectPoolConfig
at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1645)
at org.apache.catalina.loader.WebappClassLoader.loadClass(WebappClassLoader.java:1491)
上网搜了很久！都是缺少commons-pool包，导入了几次，然并卵！！！
记住这个是pool2！！
因为在commons-pool 1.x 下的包并没有mons.pool2.impl这个东西！
又找了很久原来要导入commons-pool2.x！！！包名都改了！
pom.xml加上
&commons-pool2&
搞定！！！！！
&&相关文章推荐
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：51891次
排名：千里之外
原创：22篇
评论：10条
(1)(2)(1)(5)(2)(2)(2)(7)(1)(2)apache commons pool之GenericObjectPool分析（通用对象池技术）
在高并发的环境下写程序时通常碰到线程安全的问题，当然，最能想到的就是加锁，再进一步想就是池子了，所谓池子就是，里面可以放置多个同样的对象，每个线程需要用时，就从池中取走，用完时再放回到池中，即可解决线程的安全问题，又可提高速度（预先初始化）。
当然若是自己写个对象池的话，也是可以的，不过现在有个通用的apache下的commons-pool框架，个人感觉真是不错，尤其是现在我们用到的java框架里面，为我们省去了不少的开发成本。
官方网址：http://commons.apache.org/proper/commons-pool/
本文，我先只讲下通用的GenericObjectPool的原理及使用技巧。
1、主要组成类
1.1PooledObject（可被池化的对象)
默认实现DefaultPooledObject，里面封装了一个真正的用户需要池化的对象object。
其中DefaultPooledObject里面有两个方法，感觉非常秒
1、Exception borrowedBy ：用于记录上次调用borrow时的堆栈，用于跟踪代码调用情况。
public synchronized boolean allocate() {
if (state == PooledObjectState.IDLE) {
state = PooledObjectState.ALLOCATED;
lastBorrowTime = System.currentTimeMillis();
lastUseTime = lastBorrowT
borrowedCount++;
if (logAbandoned) {
borrowedBy = new AbandonedObjectCreatedException();
} else if (state == PooledObjectState.EVICTION) {
// TODO Allocate anyway and ignore eviction test
state = PooledObjectState.EVICTION_RETURN_TO_HEAD;
// TODO if validating and testOnBorrow == true then pre-allocate for
// performance
2、Exception usedBy： 同上，记录use时的堆栈
public void use() {
lastUseTime = System.currentTimeMillis();
usedBy = new Exception(&The last code to use this object was:&);
1.2、PooledObjectState
对象的状态，也即生命周期
allocated：即为此对象被客户端使用中
idle：在池中，处于空闲状态
eviction：在实例化GenericObjectPool对象时，内部会启动一个EvictionTimer线程线程，定期（timeBetweenEvictionRunsMillis）执行evict方法，以EvictionPolicy策略destory 状态处于idle过长的对象或idle数太多的时候。
abandoned：当池中的对象被客户端拿出后，若长时间（removeAbandonedTimeout）未返回池中，或没有调用use方法，即被标记为抛弃的，当执行removeAbandoned方法时从池中destory，并若logAbandoned为true的话，则打印调用堆栈
1.3PooledObjectFactory（对象创建工厂）
一般需要程序员继承BasePooledObjectFactory，创建需要池化的对象，如
protected class NaviPoolableObjectFactory extends BasePooledObjectFactory {
private Class handleC
private ServerU
public NaviPoolableObjectFactory(Class handleClass,
ServerUrl server, String auth) {
this.handleClass = handleC
this.auth =
this.server =
public INaviDriver create() throws Exception {
return (INaviDriver)BeanUtils.instantiateClass(handleClass
.getDeclaredConstructor(ServerUrl.class, String.class,
NaviPoolConfig.class), this.server, this.auth,
poolConfig);
public void destroyObject(PooledObject p) throws Exception {
p.getObject().destroy();
public boolean validateObject(PooledObject p) {
return p.getObject().isAlive();
}catch(Exception e){
public PooledObject wrap(INaviDriver obj) {
return new DefaultPooledObject(obj);
1.4GenericObjectPoolConfig(对象池配置)
实例化GenericObjectPool需要的配置bean
lifo：后进先出，或者先进先出
maxWaitMillis：从idle队列里面取对象时，若阻塞的话，则最大等待时长
minEvictableIdleTimeMillis：处于idle状态超过此值时，会被destory
softMinEvictableIdleTimeMillis：处于idle状态超过此值，且处于idle状态个数大于minIdle时会被destory ，正常情况下softMinEvictableIdleTimeMillis <minevictableidletimemillis </minevictableidletimemillis
numTestsPerEvictionRun: evict线程每次遍历时evict的个数
testOnCreate：当create对象时，是否测试池化的对象是否存活
testOnBorrow： 同上，从池中borrow出来时测试
testOnReturn：同上，归还池中时测试
testWhileIdle：同上，idle状态时测试
timeBetweenEvictionRunsMillis：evict线程每次间隔时间
blockWhenExhausted：从池中取对象时，若池子用尽的话，是否阻塞等待一会maxWaitMillis
jmxEnabled：jmx是否开启监控
1.5AbandonedConfig（防止对象泄露）
abandoned：被抛弃的，即被池抛弃的设置（客户端从池里面取出去后，若长时间不归还池中，则抛弃并destory）并通过配置可以设置是否logAbandoned，若true的话，则把抛弃对象时，打印相关的日志（调用日志）
1.6ObjectPool(对象池)
对象池接口，客户端引用
1.7GenericObjectPool（通用对象池实现）
GenericObjectPool 继承BaseGenericObjectPool，并实现了ObjectPool、GenericObjectPoolMXBean、UsageTracking接口
public GenericObjectPool(PooledObjectFactory factory,
GenericObjectPoolConfig config) {
super(config, ONAME_BASE, config.getJmxNamePrefix());
if (factory == null) {
jmxUnregister(); // tidy up
throw new IllegalArgumentException(&factory may not be null&);
this.factory =
setConfig(config);
startEvictor(getTimeBetweenEvictionRunsMillis());
2、主要流程
2.1 evict线程流程
虚线箭头表示方法内部调用。
2.2 完整类图