implements Closeable {
+/**
+ * 对象池分区
+ * 一个分区实际为一个小的对象池，持有一个阻塞队列。
+ * 初始化时创建{@link PoolConfig#getMinSize()}个对象作为初始池对象.
+ *
+ *
+ * 当借出对象时，从队列头部取出并验证，验证通过后使用，验证不通过直接调用{@link #free(Poolable)} 销毁并重新获取，
+ * 当池中对象都被借出（空了），创建新的对象并入队列，直到队列满为止，当满时等待归还，超时则报错。
+ *
+ *
+ *
+ * 当归还对象时，验证对象，不可用销毁之，可用入队列。
+ *
+ *
+ *
+ * 一个分区队列的实际
+ *
+ *
+ * @param 对象类型
+ */
+public class PoolPartition implements ObjectPool {
+ private static final long serialVersionUID = 1L;
private final PoolConfig config;
private final ObjectFactory objectFactory;
- private BlockingQueue> queue;
+ private BlockingQueue> queue;
// 记录对象总数（包括借出对象）
private int total;
- public PoolPartition(PoolConfig config, BlockingQueue> queue, ObjectFactory objectFactory) {
+ /**
+ * 构造
+ *
+ * @param config 池配置
+ * @param queue 阻塞队列类型
+ * @param objectFactory 对象工厂，用于管理对象创建、检查和销毁
+ */
+ public PoolPartition(final PoolConfig config, final BlockingQueue> queue, final ObjectFactory objectFactory) {
this.config = config;
this.queue = queue;
this.objectFactory = objectFactory;
@@ -43,11 +71,26 @@ public class PoolPartition implements Closeable {
total = minSize;
}
- public Poolable borrowObject() {
+ @SuppressWarnings("resource")
+ @Override
+ public PartitionPoolable borrowObject() {
// 非阻塞获取
- Poolable poolable = this.queue.poll();
+ PartitionPoolable poolable = this.queue.poll();
if (null != poolable) {
- return poolable;
+ // 检查对象是否可用
+ if (this.objectFactory.validate(poolable.getRaw())) {
+ // 检查是否超过最长空闲时间
+ final long maxIdle = this.config.getMaxIdle();
+ if (maxIdle > 0 && (System.currentTimeMillis() - poolable.getLastBorrow()) <= maxIdle) {
+ poolable.setLastBorrow(System.currentTimeMillis());
+ return poolable;
+ }
+ }
+
+ // 对象不可用，销毁之
+ free(poolable);
+ // 继续借，而不扩容
+ return borrowObject();
}
// 扩容
@@ -61,24 +104,41 @@ public class PoolPartition implements Closeable {
}
// 扩容成功，继续借对象
+ // 如果线程1扩容，但是被线程2借走，则继续递归扩容获取对象，直到获取到或全部借走为止
return borrowObject();
}
/**
* 归还对象
*
- * @param obj 归还的对象
+ * @param poolable 归还的对象
* @return this
*/
- public PoolPartition returnObject(final Poolable obj) {
- try {
- this.queue.put(obj);
- } catch (InterruptedException e) {
- throw new HutoolException(e);
+ @SuppressWarnings("resource")
+ @Override
+ public PoolPartition returnObject(final Poolable poolable) {
+ // 检查对象可用性
+ if (this.objectFactory.validate(poolable.getRaw())) {
+ try {
+ this.queue.put((PartitionPoolable) poolable);
+ } catch (final InterruptedException e) {
+ throw new HutoolException(e);
+ }
+ } else {
+ // 对象不可用
+ free(poolable);
}
+
return this;
}
+ /**
+ * 扩容并填充对象池队列
+ * 如果传入的扩容大小大于可用大小（即扩容大小加现有大小大于最大大小，则实际扩容到最大）
+ *
+ * @param increaseSize 扩容大小
+ * @return 实际扩容大小，0表示已经达到最大，未成功扩容
+ */
public synchronized int increase(int increaseSize) {
if (increaseSize + total > config.getMaxSize()) {
increaseSize = config.getMaxSize() - total;
@@ -107,15 +167,21 @@ public class PoolPartition implements Closeable {
return this;
}
- /**
- * 获取对象总数，包括借出对象数
- *
- * @return 对象数
- */
+ @Override
public int getTotal() {
return this.total;
}
+ @Override
+ public int getIdleCount() {
+ return this.queue.size();
+ }
+
+ @Override
+ public int getActiveCount() {
+ return getTotal() - getIdleCount();
+ }
+
@Override
public void close() throws IOException {
this.queue.forEach(this::free);
@@ -123,11 +189,23 @@ public class PoolPartition implements Closeable {
this.queue = null;
}
- protected Poolable createPoolable() {
+ /**
+ * 创建{@link PartitionPoolable}
+ *
+ * @return {@link PartitionPoolable}
+ */
+ protected PartitionPoolable createPoolable() {
return new PartitionPoolable<>(objectFactory.create(), this);
}
- private Poolable waitingPoll() {
+ /**
+ * 从队列中取出头部的对象，如果队列为空，则等待
+ * 等待的时间取决于{@link PoolConfig#getMaxWait()}，小于等于0时一直等待，否则等待给定毫秒数
+ *
+ * @return 取出的池对象
+ * @throws HutoolException 中断异常
+ */
+ private PartitionPoolable waitingPoll() throws HutoolException {
final long maxWait = this.config.getMaxWait();
try {
if (maxWait <= 0) {
diff --git a/hutool-core/src/test/java/org/dromara/hutool/core/pool/PartitionObjectPoolTest.java b/hutool-core/src/test/java/org/dromara/hutool/core/pool/PartitionObjectPoolTest.java
new file mode 100644
index 000000000..6135465f1
--- /dev/null
+++ b/hutool-core/src/test/java/org/dromara/hutool/core/pool/PartitionObjectPoolTest.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright (c) 2023. looly(loolly@aliyun.com)
+ * Hutool is licensed under Mulan PSL v2.
+ * You can use this software according to the terms and conditions of the Mulan PSL v2.
+ * You may obtain a copy of Mulan PSL v2 at:
+ * https://license.coscl.org.cn/MulanPSL2
+ * THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
+ * EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
+ * MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
+ * See the Mulan PSL v2 for more details.
+ */
+
+package org.dromara.hutool.core.pool;
+
+import org.dromara.hutool.core.collection.ListUtil;
+import org.dromara.hutool.core.io.IoUtil;
+import org.dromara.hutool.core.pool.partition.PartitionObjectPool;
+import org.dromara.hutool.core.pool.partition.PartitionPoolConfig;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.ArrayList;
+
+public class PartitionObjectPoolTest {
+
+ public ObjectPool init() {
+ final PartitionPoolConfig config = (PartitionPoolConfig) PartitionPoolConfig.of()
+ .setPartitionSize(2)
+ .setMinSize(2)
+ .setMaxSize(20)
+ .setMaxIdle(5000)
+ .setMaxWait(100);
+
+ final ObjectFactory factory = new ObjectFactory() {
+ @Override
+ public StringBuilder create() {
+ return new StringBuilder();
+ }
+
+ @Override
+ public void destroy(final StringBuilder o) {
+ }
+
+ @Override
+ public boolean validate(final StringBuilder o) {
+ return true;
+ }
+ };
+ return new PartitionObjectPool<>(config, factory);
+ }
+
+ @Test
+ void borrowObjectTest() {
+ final ObjectPool pool = init();
+ // 初始4个对象
+ Assertions.assertEquals(4, pool.getTotal());
+
+ for (int i = 0; i < 20; i++) {
+ final Poolable obj = pool.borrowObject();
+ obj.getRaw().append("hutool");
+ }
+ // 池1的2个+池2借出的20个，合计22个
+ Assertions.assertEquals(22, pool.getTotal());
+ Assertions.assertEquals(20, pool.getActiveCount());
+ Assertions.assertEquals(2, pool.getIdleCount());
+
+ IoUtil.closeQuietly(pool);
+ }
+
+ @Test
+ void borrowAndReturnObjectTest() {
+ final ObjectPool pool = init();
+ // 初始4个对象
+ Assertions.assertEquals(4, pool.getTotal());
+
+ final ArrayList> borrowed = ListUtil.of();
+ for (int i = 0; i < 10; i++) {
+ final Poolable obj = pool.borrowObject();
+ obj.getRaw().append("hutool");
+ borrowed.add(obj);
+ }
+ // 池1的2个+池2借出的10个，合计12个
+ Assertions.assertEquals(12, pool.getTotal());
+ Assertions.assertEquals(10, pool.getActiveCount());
+ Assertions.assertEquals(2, pool.getIdleCount());
+
+ // 全部归还
+ for (final Poolable obj : borrowed) {
+ pool.returnObject(obj);
+ }
+
+ // 池1的2个+池2的10个，合计12个
+ Assertions.assertEquals(12, pool.getTotal());
+ Assertions.assertEquals(0, pool.getActiveCount());
+ // 全部空闲
+ Assertions.assertEquals(12, pool.getIdleCount());
+
+ IoUtil.closeQuietly(pool);
+ }
+}