用Java實現一個通用併發物件池
這篇文章裡我們主要討論下如何在Java裡實現一個物件池。最近幾年，Java虛擬機器的效能在各方面都得到了極大的提升，因此對大多數物件而言，已經沒有必要通過物件池來提高效能了。根本的原因是，建立一個新的物件的開銷已經不像過去那樣昂貴了。
然而，還是有些物件，它們的建立開銷是非常大的，比如執行緒，資料庫連線等這些非輕量級的物件。在任何一個應用程式裡面，我們肯定會用到不止一個這樣的物件。如果有一種很方便的建立管理這些物件的池，使得這些物件能夠動態的重用，而客戶端程式碼也不用關心它們的生命週期，還是會很給力的。
在真正開始寫程式碼前，我們先來梳理下一個物件池需要完成哪些功能。
- 如果有可用的物件，物件池應當能返回給客戶端。
- 客戶端把物件放回池裡後，可以對這些物件進行重用。
- 物件池能夠建立新的物件來滿足客戶端不斷增長的需求。
- 需要有一個正確關閉池的機制來確保關閉後不會發生記憶體洩露。
不用說了，上面幾點就是我們要暴露給客戶端的連線池的介面的基本功能。
我們的宣告的介面如下：
package com.test.pool;
/**
* Represents a cached pool of objects.
*
* @author Swaranga
*
* @param <T> the type of object to pool.
*/
public interface Pool<T>
{
/**
* Returns an instance from the pool.
* The call may be a blocking one or a non-blocking one
* and that is determined by the internal implementation.
*
* If the call is a blocking call,
* the call returns immediately with a valid object
* if available, else the thread is made to wait
* until an object becomes available.
* In case of a blocking call,
* it is advised that clients react
* to {@link InterruptedException} which might be thrown
* when the thread waits for an object to become available.
*
* If the call is a non-blocking one,
* the call returns immediately irrespective of
* whether an object is available or not.
* If any object is available the call returns it
* else the call returns < code >null< /code >.
*
* The validity of the objects are determined using the
* {@link Validator} interface, such that
* an object < code >o< /code > is valid if
* < code > Validator.isValid(o) == true < /code >.
*
* @return T one of the pooled objects.
*/
T get();
/**
* Releases the object and puts it back to the pool.
*
* The mechanism of putting the object back to the pool is
* generally asynchronous,
* however future implementations might differ.
*
* @param t the object to return to the pool
*/
void release(T t);
/**
* Shuts down the pool. In essence this call will not
* accept any more requests
* and will release all resources.
* Releasing resources are done
* via the < code >invalidate()< /code >
* method of the {@link Validator} interface.
*/
void shutdown();
}
為了能夠支援任意物件，上面這個介面故意設計得很簡單通用。它提供了從池裡獲取/返回物件的方法，還有一個關閉池的機制，以便釋放物件。
現在我們來實現一下這個介面。開始動手之前，值得一提的是，一個理想的release方法應該先嚐試檢查下這個客戶端返回的物件是否還能重複使用。如果是的話再把它扔回池裡，如果不是，就捨棄掉這個物件。我們希望這個Pool介面的所有實現都能遵循這個規則。在開始具體的實現類前，我們先建立一個抽象類，以便限制後續的實現能遵循這點。我們實現的抽象類就叫做AbstractPool，它的定義如下：
package com.test.pool;
/**
* Represents an abstract pool, that defines the procedure
* of returning an object to the pool.
*
* @author Swaranga
*
* @param <T> the type of pooled objects.
*/
abstract class AbstractPool <T> implements Pool <T>
{
/**
* Returns the object to the pool.
* The method first validates the object if it is
* re-usable and then puts returns it to the pool.
*
* If the object validation fails,
* some implementations
* will try to create a new one
* and put it into the pool; however
* this behaviour is subject to change
* from implementation to implementation
*
*/
@Override
public final void release(T t)
{
if(isValid(t))
{
returnToPool(t);
}
else
{
handleInvalidReturn(t);
}
}
protected abstract void handleInvalidReturn(T t);
protected abstract void returnToPool(T t);
protected abstract boolean isValid(T t);
}
在上面這個類裡，我們讓物件池必須得先驗證物件後才能把它放回到池裡。具體的實現可以自由選擇如何實現這三種方法，以便定製自己的行為。它們根據自己的邏輯來決定如何判斷一個物件有效，無效的話應該怎麼處理（handleInvalidReturn方法），怎麼把一個有效的物件放回到池裡（returnToPool方法）。
有了上面這幾個類，我們就可以著手開始具體的實現了。不過還有個問題，由於上面這些類是設計成能支援通用的物件池的，因此具體的實現不知道該如何驗證物件的有效性（因為物件都是泛型的）。因此我們還需要些別的東西來幫助我們完成這個。
我們需要一個通用的方法來完成物件的校驗，而具體的實現不必關心物件是何種型別。因此我們引入了一個新的介面，Validator，它定義了驗證物件的方法。這個介面的定義如下：
package com.test.pool;
/**
* Represents the functionality to
* validate an object of the pool
* and to subsequently perform cleanup activities.
*
* @author Swaranga
*
* @param < T > the type of objects to validate and cleanup.
*/
public static interface Validator < T >
{
/**
* Checks whether the object is valid.
*
* @param t the object to check.
*
* @return <code>true</code>
* if the object is valid else <code>false</code>.
*/
public boolean isValid(T t);
/**
* Performs any cleanup activities
* before discarding the object.
* For example before discarding
* database connection objects,
* the pool will want to close the connections.
* This is done via the
* <code>invalidate()</code> method.
*
* @param t the object to cleanup
*/
public void invalidate(T t);
}
上面這個介面定義了一個檢驗物件的方法，以及一個把物件置為無效的方法。當準備廢棄一個物件並清理記憶體的時候，invalidate方法就派上用場了。值得注意的是這個介面本身沒有任何意義，只有當它在物件池裡使用的時候才有意義，所以我們把這個介面定義到Pool介面裡面。這和Java集合庫裡的Map和Map.Entry是一樣的。所以我們的Pool介面就成了這樣：
package com.test.pool;
/**
* Represents a cached pool of objects.
*
* @author Swaranga
*
* @param < T > the type of object to pool.
*/
public interface Pool< T >
{
/**
* Returns an instance from the pool.
* The call may be a blocking one or a non-blocking one
* and that is determined by the internal implementation.
*
* If the call is a blocking call,
* the call returns immediately with a valid object
* if available, else the thread is made to wait
* until an object becomes available.
* In case of a blocking call,
* it is advised that clients react
* to {@link InterruptedException} which might be thrown
* when the thread waits for an object to become available.
*
* If the call is a non-blocking one,
* the call returns immediately irrespective of
* whether an object is available or not.
* If any object is available the call returns it
* else the call returns < code >null< /code >.
*
* The validity of the objects are determined using the
* {@link Validator} interface, such that
* an object < code >o< /code > is valid if
* < code > Validator.isValid(o) == true < /code >.
*
* @return T one of the pooled objects.
*/
T get();
/**
* Releases the object and puts it back to the pool.
*
* The mechanism of putting the object back to the pool is
* generally asynchronous,
* however future implementations might differ.
*
* @param t the object to return to the pool
*/
void release(T t);
/**
* Shuts down the pool. In essence this call will not
* accept any more requests
* and will release all resources.
* Releasing resources are done
* via the < code >invalidate()< /code >
* method of the {@link Validator} interface.
*/
void shutdown();
/**
* Represents the functionality to
* validate an object of the pool
* and to subsequently perform cleanup activities.
*
* @author Swaranga
*
* @param < T > the type of objects to validate and cleanup.
*/
public static interface Validator < T >
{
/**
* Checks whether the object is valid.
*
* @param t the object to check.
*
* @return <code>true</code>
* if the object is valid else <code>false</code>.
*/
public boolean isValid(T t);
/**
* Performs any cleanup activities
* before discarding the object.
* For example before discarding
* database connection objects,
* the pool will want to close the connections.
* This is done via the
* <code>invalidate()</code> method.
*
* @param t the object to cleanup
*/
public void invalidate(T t);
}
}
準備工作已經差不多了，在最後開始前我們還需要一個終極武器，這才是這個物件池的殺手鐗。就是“能夠建立新的物件”。我們的物件池是泛型的，因此它們得知道如何去生成新的物件來填充這個池子。這個功能不能依賴於物件池本身，必須要有一個通用的方式來建立新的物件。通過一個ObjectFactory的介面就能完成這個，它只有一個“如何建立新的物件”的方法。我們的ObjectFactory介面如下：
package com.test.pool;
/**
* Represents the mechanism to create
* new objects to be used in an object pool.
*
* @author Swaranga
*
* @param < T > the type of object to create.
*/
public interface ObjectFactory < T >
{
/**
* Returns a new instance of an object of type T.
*
* @return T an new instance of the object of type T
*/
public abstract T createNew();
}
我們的工具類都已經搞定了，現在可以開始真正實現我們的Pool介面了。因為我們希望這個池能在併發程式裡面使用，所以我們會建立一個阻塞的物件池，當沒有物件可用的時候，讓客戶端先阻塞住。我們的阻塞機制是讓客戶端一直阻塞直到有物件可用為止。這樣的話導致我們還需要再增加一個只阻塞一定時間的方法，如果在超時時間到來前有物件可用則返回，如果超時了就返回null而不是一直等待下去。這樣的實現有點類似Java併發庫裡的LinkedBlockingQueue，因此真正實現前我們再暴露一個介面，BlockingPool，類似於Java併發庫裡的BlockingQueue介面。
這裡是BlockingQueue的宣告：
package com.test.pool;
import java.util.concurrent.TimeUnit;
/**
* Represents a pool of objects that makes the
* requesting threads wait if no object is available.
*
* @author Swaranga
*
* @param < T > the type of objects to pool.
*/
public interface BlockingPool < T > extends Pool < T >
{
/**
* Returns an instance of type T from the pool.
*
* The call is a blocking call,
* and client threads are made to wait
* indefinitely until an object is available.
* The call implements a fairness algorithm
* that ensures that a FCFS service is implemented.
*
* Clients are advised to react to InterruptedException.
* If the thread is interrupted while waiting
* for an object to become available,
* the current implementations
* sets the interrupted state of the thread
* to <code>true</code> and returns null.
* However this is subject to change
* from implementation to implementation.
*
* @return T an instance of the Object
* of type T from the pool.
*/
T get();
/**
* Returns an instance of type T from the pool,
* waiting up to the
* specified wait time if necessary
* for an object to become available..
*
* The call is a blocking call,
* and client threads are made to wait
* for time until an object is available
* or until the timeout occurs.
* The call implements a fairness algorithm
* that ensures that a FCFS service is implemented.
*
* Clients are advised to react to InterruptedException.
* If the thread is interrupted while waiting
* for an object to become available,
* the current implementations
* set the interrupted state of the thread
* to <code>true</code> and returns null.
* However this is subject to change
* from implementation to implementation.
*
*
* @param time amount of time to wait before giving up,
* in units of <tt>unit</tt>
* @param unit a <tt>TimeUnit</tt> determining
* how to interpret the
* <tt>timeout</tt> parameter
*
* @return T an instance of the Object
* of type T from the pool.
*
* @throws InterruptedException
* if interrupted while waiting
*/
T get(long time, TimeUnit unit) throws InterruptedException;
}
BoundedBlockingPool的實現如下：
package com.test.pool;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.TimeUnit;
public final class BoundedBlockingPool
extends <AbstractPool>
implements <BlockingPool>
{
private int size;
private BlockingQueue objects;
private Validator validator;
private ObjectFactory objectFactory;
private ExecutorService executor =
Executors.newCachedThreadPool();
private volatile boolean shutdownCalled;
public BoundedBlockingPool(
int size,
Validator validator,
ObjectFactory objectFactory)
{
super();
this.objectFactory = objectFactory;
this.size = size;
this.validator = validator;
objects = new LinkedBlockingQueue (size);
initializeObjects();
shutdownCalled = false;
}
public T get(long timeOut, TimeUnit unit)
{
if(!shutdownCalled)
{
T t = null;
try
{
t = objects.poll(timeOut, unit);
return t;
}
catch(InterruptedException ie)
{
Thread.currentThread().interrupt();
}
return t;
}
throw new IllegalStateException(
'Object pool is already shutdown');
}
public T get()
{
if(!shutdownCalled)
{
T t = null;
try
{
t = objects.take();
}
catch(InterruptedException ie)
{
Thread.currentThread().interrupt();
}
return t;
}
throw new IllegalStateException(
'Object pool is already shutdown');
}
public void shutdown()
{
shutdownCalled = true;
executor.shutdownNow();
clearResources();
}
private void clearResources()
{
for(T t : objects)
{
validator.invalidate(t);
}
}
@Override
protected void returnToPool(T t)
{
if(validator.isValid(t))
{
executor.submit(new ObjectReturner(objects, t));
}
}
@Override
protected void handleInvalidReturn(T t)
{
}
@Override
protected boolean isValid(T t)
{
return validator.isValid(t);
}
private void initializeObjects()
{
for(int i = 0; i < size; i++)
{
objects.add(objectFactory.createNew());
}
}
private class ObjectReturner
implements <Callable>
{
private BlockingQueue queue;
private E e;
public ObjectReturner(BlockingQueue queue, E e)
{
this.queue = queue;
this.e = e;
}
public Void call()
{
while(true)
{
try
{
queue.put(e);
break;
}
catch(InterruptedException ie)
{
Thread.currentThread().interrupt();
}
}
return null;
}
}
}
上面是一個非常基本的物件池，它內部是基於一個LinkedBlockingQueue來實現的。這裡唯一比較有意思的方法就是returnToPool。因為內部的儲存是一個LinkedBlockingQueue實現的，如果我們直接把返回的物件扔進去的話，如果佇列已滿可能會阻塞住客戶端。不過我們不希望客戶端因為把物件放回池裡這麼個普通的方法就阻塞住了。所以我們把最終將物件插入到佇列裡的任務作為一個非同步的的任務提交給一個Executor來執行，以便讓客戶端執行緒能立即返回。
現在我們將在自己的程式碼中使用上面這個物件池，用它來快取資料庫連線。我們需要一個校驗器來驗證資料庫連線是否有效。
下面是這個JDBCConnectionValidator：
package com.test;
import java.sql.Connection;
import java.sql.SQLException;
import com.test.pool.Pool.Validator;
public final class JDBCConnectionValidator implements Validator < Connection >
{
public boolean isValid(Connection con)
{
if(con == null)
{
return false;
}
try
{
return !con.isClosed();
}
catch(SQLException se)
{
return false;
}
}
public void invalidate(Connection con)
{
try
{
con.close();
}
catch(SQLException se)
{
}
}
}
還有一個JDBCObjectFactory，它將用來生成新的資料庫連線物件：
package com.test;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
import com.test.pool.ObjectFactory;
public class JDBCConnectionFactory implements ObjectFactory < Connection >
{
private String connectionURL;
private String userName;
private String password;
public JDBCConnectionFactory(
String driver,
String connectionURL,
String userName,
String password) {
super();
try
{
Class.forName(driver);
}
catch(ClassNotFoundException ce)
{
throw new IllegalArgumentException('Unable to find driver in classpath', ce);
}
this.connectionURL = connectionURL;
this.userName = userName;
this.password = password;
}
public Connection createNew()
{
try
{
return DriverManager.getConnection(
connectionURL,
userName,
password);
}
catch(SQLException se)
{
throw new IllegalArgumentException('Unable to create new connection', se);
}
}
}
現在我們用上述的Validator和ObjectFactory來建立一個JDBC的連線池：
package com.test;
import java.sql.Connection;
import com.test.pool.Pool;
import com.test.pool.PoolFactory;
public class Main
{
public static void main(String[] args)
{
Pool < Connection > pool =
new BoundedBlockingPool < Connection > (
10,
new JDBCConnectionValidator(),
new JDBCConnectionFactory('', '', '', '')
);
//do whatever you like
}
}
為了犒勞下能讀完整篇文章的讀者，我這再提供另一個非阻塞的物件池的實現，這個實現和前面的唯一不同就是即使物件不可用，它也不會讓客戶端阻塞，而是直接返回null。具體的實現在這：
package com.test.pool;
import java.util.LinkedList;
import java.util.Queue;
import java.util.concurrent.Semaphore;
public class BoundedPool < T > extends AbstractPool < T >
{
private int size;
private Queue < T > objects;
private Validator < T > validator;
private ObjectFactory < T > objectFactory;
private Semaphore permits;
private volatile boolean shutdownCalled;
public BoundedPool(
int size,
Validator < T > validator,
ObjectFactory < T > objectFactory)
{
super();
this.objectFactory = objectFactory;
this.size = size;
this.validator = validator;
objects = new LinkedList < T >();
initializeObjects();
shutdownCalled = false;
}
@Override
public T get()
{
T t = null;
if(!shutdownCalled)
{
if(permits.tryAcquire())
{
t = objects.poll();
}
}
else
{
throw new IllegalStateException('Object pool already shutdown');
}
return t;
}
@Override
public void shutdown()
{
shutdownCalled = true;
clearResources();
}
private void clearResources()
{
for(T t : objects)
{
validator.invalidate(t);
}
}
@Override
protected void returnToPool(T t)
{
boolean added = objects.add(t);
if(added)
{
permits.release();
}
}
@Override
protected void handleInvalidReturn(T t)
{
}
@Override
protected boolean isValid(T t)
{
return validator.isValid(t);
}
private void initializeObjects()
{
for(int i = 0; i < size; i++)
{
objects.add(objectFactory.createNew());
}
}
}
考慮到我們現在已經有兩種實現，非常威武了，得讓使用者通過工廠用具體的名稱來建立不同的物件池了。工廠來了:
package com.test.pool;
import com.test.pool.Pool.Validator;
/**
* Factory and utility methods for
* {@link Pool} and {@link BlockingPool} classes
* defined in this package.
* This class supports the following kinds of methods:
*
*
<ul>
*
<li> Method that creates and returns a default non-blocking
* implementation of the {@link Pool} interface.
* </li>
*
*
<li> Method that creates and returns a
* default implementation of
* the {@link BlockingPool} interface.
* </li>
*
</ul>
*
* @author Swaranga
*/
public final class PoolFactory
{
private PoolFactory()
{
}
/**
* Creates a and returns a new object pool,
* that is an implementation of the {@link BlockingPool},
* whose size is limited by
* the <tt> size </tt> parameter.
*
* @param size the number of objects in the pool.
* @param factory the factory to create new objects.
* @param validator the validator to
* validate the re-usability of returned objects.
*
* @return a blocking object pool
* bounded by <tt> size </tt>
*/
public static < T > Pool < T >
newBoundedBlockingPool(
int size,
ObjectFactory < T > factory,
Validator < T > validator)
{
return new BoundedBlockingPool < T > (
size,
validator,
factory);
}
/*
* Creates a and returns a new object pool,
* that is an implementation of the {@link Pool}
* whose size is limited
* by the <tt> size </tt> parameter.
*
* @param size the number of objects in the pool.
* @param factory the factory to create new objects.
* @param validator the validator to validate
* the re-usability of returned objects.
*
* @return an object pool bounded by <tt> size </tt>
*/
public static < T > Pool < T > newBoundedNonBlockingPool(
int size,
ObjectFactory < T > factory,
Validator < T > validator)
{
return new BoundedPool < T >(size, validator, factory);
}
}
現在我們的客戶端就能用一種可讀性更強的方式來建立物件池了：
package com.test;
import java.sql.Connection;
import com.test.pool.Pool;
import com.test.pool.PoolFactory;
public class Main
{
public static void main(String[] args)
{
Pool < Connection > pool =
PoolFactory.newBoundedBlockingPool(
10,
new JDBCConnectionFactory('', '', '', ''),
new JDBCConnectionValidator());
//do whatever you like
}
}
好吧，終於寫完了，拖了這麼久了。盡情使用和完善它吧，或者再多加幾種實現。
快樂編碼，快樂分享！
相關文章
- 物件池技術和通用實現GenericObjectPool物件Object
- Java 中的物件池實現Java物件
- 一個排序的有界的併發Buffer佇列Java實現排序佇列Java
- 用Java 19實現類似Go併發 - mccueJavaGo
- 物件池簡單實現物件
- Java併發系列 — 執行緒池Java執行緒
- 實現一個併發任務執行框架框架
- 實現一個redis連線池Redis
- java併發之SynchronousQueue實現原理Java
- Java 併發集合的實現原理Java
- java多執行緒與併發 - 自己實現一個簡單的鎖(實現Lock介面)Java執行緒
- 使用concurrent.futures模組併發，實現程式池、執行緒池執行緒
- Java中實現1,000,000個併發連線Java
- 不到50行程式碼實現一個能對請求併發數做限制的通用RequestDecorator行程
- java實現下載器（以及建立一個URL物件)Java物件
- [Java併發系列] 1.Java併發機制的底層實現Java
- Java併發程式設計實戰--事實不可變物件Java程式設計物件
- Java併發——執行緒池ThreadPoolExecutorJava執行緒thread
- Java併發指南12：深度解讀 java 執行緒池設計思想及原始碼實現Java執行緒原始碼
- 《JAVA併發程式設計實戰》物件的組合Java程式設計物件
- 通過Guava實現兩個包含不同物件的List合併成一個ListGuava物件
- Unity實現簡單的物件池Unity物件
- Java併發和多執行緒4：使用通用同步工具CountDownLatch實現執行緒等待Java執行緒CountDownLatch
- JAVA進階：一個簡單Thread緩衝池的實現Javathread
- Android中的Message類以及Java物件池的實現AndroidJava物件
- 多個APP合併為一個APP開發的實現方案APP
- Java併發（11）- 有關執行緒池的10個問題Java執行緒
- Java併發基礎（2）------執行緒池Java執行緒
- java併發程式設計——執行緒池Java程式設計執行緒
- 用go實現併發聊天室Go
- 和朱曄一起復習Java併發（一）：執行緒池Java執行緒
- 學習之路 / goroutine 併發協程池設計及實現Go
- 一個PHP通用隨機密碼的實現PHP隨機密碼
- 一個故事搞懂Java併發程式設計Java程式設計
- Java併發指南9：AQS共享模式與併發工具類的實現JavaAQS模式
- 《java併發程式設計的藝術》併發底層實現原理Java程式設計
- 設計一個物件池（Anno.XObjectPool）物件Object
- JAVA 併發之路 （三）物件的共享 （1）Java物件