构建简单的socket连接池

一开始，选用Vector<E>来存放连接。由于这个容器不是并发安全的，于是，每个方法都加一个synchronized来保持并发时的同步操作，并发效率很差，果断放弃。空余时间研究了下多线程的并发知识，决定用并发安全的阻塞队列（LinkedBlockingQueue<E>）,这个容器可以自动维护容量的大小，就免去了再起一个线程去维护线程池的大小。为了保证每个连接是可用的，为线程池启动了一个守护线程去定时发送心跳。

程序如下，欢迎高手们指点缺陷：

 public class SocketConnectionPool {

     private ConnectionPoolConfig poolConfig; // 连接池配置
     private LinkedBlockingQueue<SocketConnection> freeConnections; // 空闲池连接

     public ConnectionPoolConfig getPoolConfig() {
         return poolConfig;
     }     public LinkedBlockingQueue<SocketConnection> getFreeConnections() {
         return freeConnections;
     }
     /**
      * 功能描述：连接池构造方法
      *
      * @author mihu
      * @version mihu
      * @param config
      * @throws UnknownHostException
      * @throws IOException
      */
     public SocketConnectionPool(ConnectionPoolConfig config){
         try {
             if(config == null){
                 log.error("func[init] ConnectionPoolConfig is null ......");
                 return;
             }

             this.poolConfig = config;
             this.freeConnections = new LinkedBlockingQueue<SocketConnection>(config.getMaxConn());  //构造指定大小的阻塞队列

             init();

         } catch (UnknownHostException e) {
             e.printStackTrace();
         } catch (ConnectException e){
             e.printStackTrace();
         } catch (SocketTimeoutException e){
             e.printStackTrace();
         } catch (IOException e) {
             e.printStackTrace();
         } catch (Exception e) {
             e.printStackTrace();
         } finally{

             //心跳检测守护线程
             if(config != null){
                 ACheckThread aCheckThread = new ACheckThread(this);
                 aCheckThread.setDaemon(true);
                 aCheckThread.start();
             }
         }
     }

     /**
      * 功能描述：初始化连接池
      *
      * @return
      * @throws UnknownHostException
      * @throws IOException
      * @author mihu
      * @version mihu
      * @throws InterruptedException
      * @since 2013-7-2
      *
      */
     public void init() throws UnknownHostException, IOException,SocketTimeoutException,ConnectException, InterruptedException{

         for(int i=0; i<poolConfig.getMinConn(); i++){
             SocketConnection client = new SocketConnection(poolConfig.getHost(), poolConfig.getPort());
             freeConnections.offer(client);
         }

     }

     /**
      * 功能描述：新建连接
      *
      * @param totalConnSize
      * @throws UnknownHostException
      * @throws IOException
      * @author mihu
      * @version mihu
      * @since 2013-7-2
      *
      */
     public SocketConnection newConnection() throws UnknownHostException, IOException{
         SocketConnection client = new SocketConnection(this.poolConfig.getHost(), this.poolConfig.getPort());

         return client;
     }

     /**
      * 功能描述：获取连接
      *
      * @return SocketConnection连接
      * @throws UnknownHostException
      * @throws IOException
      * @author mihu
      * @version mihu
      * @throws InterruptedException
      * @since 2013-7-2
      *
      */
     public SocketConnection getConnection() throws UnknownHostException, IOException, InterruptedException{
         if(freeConnections.size()==0){
             synchronized (freeConnections) {
                 int freeConnCount = freeConnections.size();
                 if(freeConnCount == 0 && freeConnCount < this.poolConfig.getMaxConn()){
                     SocketConnection client = newConnection();
                     return client;
                 }
             }
         }

         SocketConnection client = freeConnections.poll(2000,TimeUnit.MILLISECONDS);

         return client;
     }

     /**
      * 功能描述：将连接还回连接池
      *
      * @param client
      * @throws IOException
      * @author mihu
      * @version mihu
      * @throws InterruptedException
      * @since 2013-7-2
      *
      */
     public void freeConnection(SocketConnection client) throws IOException, InterruptedException{
         if(null != client && !client.isClosed()){
             freeConnections.offer(client);
         }
     }

 }

以上连接池的代码已经被废弃了，多线程下问题多多。

某天在网上看到数据库连接池的开源代码boneCP，据说是当前最高效的数据库连接池。于是下载了它的源码学习了一番，发现它的代码简洁，可阅读性强，没有过多的使用锁机制来避免临界竞争，这一点和c3p0很不同。

最后根据boneCP的思维重构了自己的socket连接池，完全满足了应用的需求，哈哈~~~