Java对象池模型
1 Java对象池模型的介绍
通常，性能是软件开发和对象创建过程中的关键问题，这可能是一个昂贵的步骤。
对象池模式说“重用创建昂贵的对象”。
基本上，对象池是一个包含指定数量的对象的容器。从池中获取对象时，在将对象放回之前，该对象在池中不可用。池中的对象具有生命周期：创建，验证和销毁。
池有助于更好地管理可用资源。有许多使用示例：特别是在应用服务器中，有数据源池，线程池等。
2 Java对象池模型的好处
- 对象池模式显着提高了应用程序的性能。
- 在初始化类实例的速率很高的情况下，这是最有效的。
- 它管理连接并提供重用和共享它们的方法。
- 它还可以为可以创建的最大对象数提供限制。
3 Java对象池模型的用法
- 当应用程序需要创建昂贵的对象时。例如：需要为数据库打开太多连接，然后创建一个新连接所需的时间太长，数据库服务器将过载。
- 当有多个客户端在不同时间需要相同的资源时。
4 Java对象池模型的UML
5 Java对象池模型的案例
5.1 创建一个用于创建对象数量的ObjectPool类
ObjectPool.java：
package com.yiidian;
import java.util.concurrent.ConcurrentLinkedQueue;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
/**
* 一点教程网： http://www.yiidian.com
*/
public abstract class ObjectPool<T> {
/*
pool implementation is based on ConcurrentLinkedQueue from the java.util.concurrent package.
ConcurrentLinkedQueue is a thread-safe queue based on linked nodes.
Because the queue follows FIFO technique (first-in-first-out).
*/
private ConcurrentLinkedQueue<T> pool;
/*
ScheduledExecutorService starts a special task in a separate thread and observes
the minimum and maximum number of objects in the pool periodically in a specified
time (with parameter validationInterval).
When the number of objects is less than the minimum, missing instances will be created.
When the number of objects is greater than the maximum, too many instances will be removed.
This is sometimes useful for the balance of memory consuming objects in the pool.
*/
private ScheduledExecutorService executorService;
/*
* Creates the pool.
*
* @param minObjects : the minimum number of objects residing in the pool
*/
public ObjectPool(final int minObjects)
{
// initialize pool
initialize(minObjects);
}
/*
Creates the pool.
@param minObjects: minimum number of objects residing in the pool.
@param maxObjects: maximum number of objects residing in the pool.
@param validationInterval: time in seconds for periodical checking of
minObjects / maxObjects conditions in a separate thread.
When the number of objects is less than minObjects, missing instances will be created.
When the number of objects is greater than maxObjects, too many instances will be removed.
*/
public ObjectPool(final int minObjects, final int maxObjects, final long validationInterval) {
// initialize pool
initialize(minObjects);
// check pool conditions in a separate thread
executorService = Executors.newSingleThreadScheduledExecutor();
executorService.scheduleWithFixedDelay(new Runnable() // annonymous class
{
@Override
public void run() {
int size = pool.size();
if (size < minObjects) {
int sizeToBeAdded = minObjects + size;
for (int i = 0; i < sizeToBeAdded; i++) {
pool.add(createObject());
}
} else if (size > maxObjects) {
int sizeToBeRemoved = size - maxObjects;
for (int i = 0; i < sizeToBeRemoved; i++) {
pool.poll();
}
}
}
}, validationInterval, validationInterval, TimeUnit.SECONDS);
}
/*
Gets the next free object from the pool. If the pool doesn't contain any objects,
a new object will be created and given to the caller of this method back.
@return T borrowed object
*/
public T borrowObject() {
T object;
if ((object = pool.poll()) == null)
{
object = createObject();
}
return object;
}
/*
Returns object back to the pool.
@param object object to be returned
*/
public void returnObject(T object) {
if (object == null) {
return;
}
this.pool.offer(object);
}
/*
Shutdown this pool.
*/
public void shutdown(){
if (executorService != null){
executorService.shutdown();
}
}
/*
Creates a new object.
@return T new object
*/
protected abstract T createObject();
private void initialize(final int minObjects) {
pool = new ConcurrentLinkedQueue<T>();
for (int i = 0; i < minObjects; i++) {
pool.add(createObject());
}
}
}
5.2 创建一个ExportingProcess类，ExportingTask类将使用该类
ExportingProcess.java：
package com.yiidian;
/**
* 一点教程网： http://www.yiidian.com
*/
public class ExportingProcess {
private long processNo;
public ExportingProcess(long processNo) {
this.processNo = processNo;
// do some expensive calls / tasks here in future
// .........
System.out.println("Object with process no. " + processNo + " was created");
}
public long getProcessNo() {
return processNo;
}
}
5.3 创建一个ExportingTask类，它将使用ExportingProcess和ObjectPool类
ExportingTask.java：
package com.yiidian;
/**
* 一点教程网： http://www.yiidian.com
*/
public class ExportingTask implements Runnable {
private ObjectPool<ExportingProcess> pool;
private int threadNo;
public ExportingTask(ObjectPool<ExportingProcess> pool, int threadNo){
this.pool = pool;
this.threadNo = threadNo;
}
public void run() {
// get an object from the pool
ExportingProcess exportingProcess = pool.borrowObject();
System.out.println("Thread " + threadNo + ": Object with process no. "
+ exportingProcess.getProcessNo() + " was borrowed");
//you can do something here in future
// .........
// return ExportingProcess instance back to the pool
pool.returnObject(exportingProcess);
System.out.println("Thread " + threadNo +": Object with process no. "
+ exportingProcess.getProcessNo() + " was returned");
}
}
5.4 创建一个ObjectPoolDemo类
ObjectPoolDemo.java：
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;
/**
* 一点教程网： http://www.yiidian.com
*/
public class ObjectPoolDemo{
private ObjectPool<ExportingProcess> pool;
private AtomicLong processNo=new AtomicLong(0);
public void setUp() {
// Create a pool of objects of type ExportingProcess.
/*Parameters:
1) Minimum number of special ExportingProcess instances residing in the pool = 4
2) Maximum number of special ExportingProcess instances residing in the pool = 10
3) Time in seconds for periodical checking of minObjects / maxObjects conditions
in a separate thread = 5.
-->When the number of ExportingProcess instances is less than minObjects,
missing instances will be created.
-->When the number of ExportingProcess instances is greater than maxObjects,
too many instances will be removed.
-->If the validation interval is negative, no periodical checking of
minObjects / maxObjects conditions in a separate thread take place.
These boundaries are ignored then.
*/
pool = new ObjectPool<ExportingProcess>(4, 10, 5)
{
protected ExportingProcess createObject()
{
// create a test object which takes some time for creation
return new ExportingProcess( processNo.incrementAndGet());
}
};
}
public void tearDown() {
pool.shutdown();
}
public void testObjectPool() {
ExecutorService executor = Executors.newFixedThreadPool(8);
// execute 8 tasks in separate threads
executor.execute(new ExportingTask(pool, 1));
executor.execute(new ExportingTask(pool, 2));
executor.execute(new ExportingTask(pool, 3));
executor.execute(new ExportingTask(pool, 4));
executor.execute(new ExportingTask(pool, 5));
executor.execute(new ExportingTask(pool, 6));
executor.execute(new ExportingTask(pool, 7));
executor.execute(new ExportingTask(pool, 8));
executor.shutdown();
try {
executor.awaitTermination(30, TimeUnit.SECONDS);
} catch (InterruptedException e)
{
e.printStackTrace();
}
}
public static void main(String args[]) {
ObjectPoolDemo op=new ObjectPoolDemo();
op.setUp();
op.tearDown();
op.testObjectPool();
}
}
5.5 输出结果
热门文章
优秀文章
