浅谈轻量级socket连接池实现

最新推荐文章于 2024-04-22 07:46:44 发布
最新推荐文章于 2024-04-22 07:46:44 发布
阅读量969 收藏 3
点赞数
文章标签： 网络 redis java http c3p0
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38130500/article/details/106632451
版权

1. 背景

前段时间有幸参与到开源轻量级分布式文件系统Fastdfs Java-SDK的改造,

支持连接池和短连接两种方式,是否开启连接池可选(默认开启),短连接(用完即关闭)

2. 如何实现

调研了连接池下,网上很多socket连接池都是用Apache Commons Pool来实现的,个人感觉可能有点重,所以就完全原生代码实现连接池开发了。

3. 实现代码

  • socket连接类

    public class Connection {

  private Socket sock;
  private InetSocketAddress inetSockAddr;
  private Long lastAccessTime = System.currentTimeMillis();
  private boolean needActiveTest = false;

  public Connection(Socket sock, InetSocketAddress inetSockAddr) {
      this.sock = sock;
      this.inetSockAddr = inetSockAddr;
  }

  /**
   * get the server info
   *
   * @return the server info
   */
  public InetSocketAddress getInetSocketAddress() {
      return this.inetSockAddr;
  }

  public OutputStream getOutputStream() throws IOException {
      return this.sock.getOutputStream();
  }

  public InputStream getInputStream() throws IOException {
      return this.sock.getInputStream();
  }

  public Long getLastAccessTime() {
      return lastAccessTime;
  }

  public void setLastAccessTime(Long lastAccessTime) {
      this.lastAccessTime = lastAccessTime;
  }

  /**
   *
   * @throws IOException
   */
  public void close() throws IOException {
      //if connection enabled get from connection pool
      if (ClientGlobal.g_connection_pool_enabled) {
          ConnectionPool.closeConnection(this);
      } else {
          this.closeDirectly();
      }
  }

  public void release() throws IOException {
      if (ClientGlobal.g_connection_pool_enabled) {
          ConnectionPool.releaseConnection(this);
      } else {
          this.closeDirectly();
      }
  }

  /**
   * force close socket,
   */
  public void closeDirectly() throws IOException {
      if (this.sock != null) {
          try {
              ProtoCommon.closeSocket(this.sock);
          } finally {
              this.sock = null;
          }
      }
  }

  public boolean activeTest() throws IOException {
      if (this.sock == null) {
          return false;
      }
      return ProtoCommon.activeTest(this.sock);
  }

  public boolean isConnected() {
      boolean isConnected = false;
      if (sock != null) {
          if (sock.isConnected()) {
              isConnected = true;
          }
      }
      return isConnected;
  }
  public boolean isAvaliable() {
      if (isConnected()) {
          if (sock.getPort() == 0) {
              return false;
          }
          if (sock.getInetAddress() == null) {
              return false;
          }
          if (sock.getRemoteSocketAddress() == null) {
              return false;
          }
          if (sock.isInputShutdown()) {
              return false;
          }
          if (sock.isOutputShutdown()) {
              return false;
          }
          return true;
      }
      return false;
  }

  public boolean isNeedActiveTest() {
      return needActiveTest;
  }

  public void setNeedActiveTest(boolean needActiveTest) {
      this.needActiveTest = needActiveTest;
  }
}

  • 连接管理器(主要职责:获取连接，关闭连接，释放连接)

public class ConnectionManager {

    private InetSocketAddress inetSocketAddress;

    /**
     * count of total connections 
     */
    private AtomicInteger totalCount = new AtomicInteger();

    /**
     * count of free connections
     */
    private AtomicInteger freeCount = new AtomicInteger();

    /**
     * lock
     */
    private ReentrantLock lock = new ReentrantLock(true);

    private Condition condition = lock.newCondition();

    /**
     * free container connection  
     */
    private LinkedList<Connection> freeConnections = new LinkedList<Connection>();

    private ConnectionManager() {

    }

    public ConnectionManager(InetSocketAddress socketAddress) {
        this.inetSocketAddress = socketAddress;
    }

   /**
    * get connection
    **/
    public Connection getConnection() throws MyException {
        lock.lock();
        try {
            Connection connection = null;
            while (true) {
                if (freeCount.get() > 0) {
                    freeCount.decrementAndGet();
                    connection = freeConnections.poll();
                    if (!connection.isAvaliable() || (System.currentTimeMillis() - connection.getLastAccessTime()) > ClientGlobal.g_connection_pool_max_idle_time) {
                        closeConnection(connection);
                        continue;
                    }
                    if (connection.isNeedActiveTest()) {
                        boolean isActive = false;
                        try {
                            isActive = connection.activeTest();
                        } catch (IOException e) {
                            System.err.println("send to server[" + inetSocketAddress.getAddress().getHostAddress() + ":" + inetSocketAddress.getPort() + "] active test fail ,emsg:" + e.getMessage());
                            isActive = false;
                        }
                        if (!isActive) {
                            closeConnection(connection);
                            continue;
                        } else {
                            connection.setNeedActiveTest(false);
                        }
                    }
                } else if (ClientGlobal.g_connection_pool_max_count_per_entry == 0 || totalCount.get() < ClientGlobal.g_connection_pool_max_count_per_entry) {
                    connection = ConnectionFactory.create(this.inetSocketAddress);
                    totalCount.incrementAndGet();
                } else {
                    try {
                        if (condition.await(ClientGlobal.g_connection_pool_max_wait_time_in_ms, TimeUnit.MILLISECONDS)) {
                            //wait single success
                            continue;
                        }
                        throw new MyException("connect to server " + inetSocketAddress.getAddress().getHostAddress() + ":" + inetSocketAddress.getPort() + " fail, wait_time > " + ClientGlobal.g_connection_pool_max_wait_time_in_ms + "ms");
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        throw new MyException("connect to server " + inetSocketAddress.getAddress().getHostAddress() + ":" + inetSocketAddress.getPort() + " fail, emsg:" + e.getMessage());
                    }
                }
                return connection;
            }
        } finally {
            lock.unlock();
        }
    }

   /**
   *release connection
   */
    public void releaseConnection(Connection connection) {
        if (connection == null) {
            return;
        }
        lock.lock();
        try {
            connection.setLastAccessTime(System.currentTimeMillis());
            freeConnections.add(connection);
            freeCount.incrementAndGet();
            condition.signal();
        } finally {
            lock.unlock();
        }

    }

    /**
     *close connection
     *
     */
    public void closeConnection(Connection connection) {
        try {
            if (connection != null) {
                totalCount.decrementAndGet();
                connection.closeDirectly();
            }
        } catch (IOException e) {
            System.err.println("close socket[" + inetSocketAddress.getAddress().getHostAddress() + ":" + inetSocketAddress.getPort() + "] error ,emsg:" + e.getMessage());
            e.printStackTrace();
        }
    }

    public void setActiveTestFlag() {
        if (freeCount.get() > 0) {
            lock.lock();
            try {
                for (Connection freeConnection : freeConnections) {
                    freeConnection.setNeedActiveTest(true);
                }
            } finally {
                lock.unlock();
            }
        }
    }

}

注:其中setActiveTestFlag()方法解释一下,有可能出现连接断了之后，可能是这台服务器重启了，或者网络抽风导致闪断。希望只牺牲一次请求,主要解决服务器重启问题

大致思路就是一旦client请求时一旦有连接出现IOException,就会将所有当前实例对应的所有连接全部变为需要activeTest,当下一个连接获取时,就会检测所有的连接,从而达到只牺牲一次请求的目的.

  • 管理器连接池(由于存在多个实例,一个实例对应一个ConnectionManager,连接获取,释放,关闭的入口)

public class ConnectionPool {
    /**
     * key is ip:port, value is ConnectionManager
     */
    private final static ConcurrentHashMap<String, ConnectionManager> CP = new ConcurrentHashMap<String, ConnectionManager>();

    public static Connection getConnection(InetSocketAddress socketAddress) throws MyException {
        if (socketAddress == null) {
            return null;
        }
        String key = getKey(socketAddress);
        ConnectionManager connectionManager;
        connectionManager = CP.get(key);
        if (connectionManager == null) {
            synchronized (ConnectionPool.class) {
                connectionManager = CP.get(key);
                if (connectionManager == null) {
                    connectionManager = new ConnectionManager(socketAddress);
                    CP.put(key, connectionManager);
                }
            }
        }
        return connectionManager.getConnection();
    }

    public static void releaseConnection(Connection connection) throws IOException {
        if (connection == null) {
            return;
        }
        String key = getKey(connection.getInetSocketAddress());
        ConnectionManager connectionManager = CP.get(key);
        if (connectionManager != null) {
            connectionManager.releaseConnection(connection);
        } else {
            connection.closeDirectly();
        }

    }

    public static void closeConnection(Connection connection) throws IOException {
        if (connection == null) {
            return;
        }
        String key = getKey(connection.getInetSocketAddress());
        ConnectionManager connectionManager = CP.get(key);
        if (connectionManager != null) {
            connectionManager.closeConnection(connection);
            connectionManager.setActiveTestFlag();
        } else {
            connection.closeDirectly();
        }
    }

    private static String getKey(InetSocketAddress socketAddress) {
        if (socketAddress == null) {
            return null;
        }
        return String.format("%s:%s", socketAddress.getAddress().getHostAddress(), socketAddress.getPort());
 }

以上代码已发布于fastdfs-client-java V1.28版本

更多具体实现及源码请查看:https://github.com/happyfish100/fastdfs-client-java/tree/master/src/main/java/org/csource/fastdfs/pool

近期热文

*  浅谈扩展字段设计

  

谢谢阅读！欢迎转发、点赞、关注!

AI觉醒实战营
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
浅谈c++内存管理
程序猿的博客
07-22 595
内存管理是C++最令人切齿痛恨的问题，也是C++最有争议的问题，C++高手从中获得了更好的性能，更大的自由，C++菜鸟的收获则是一遍一遍的检查代码和对C++的痛恨，但内存管理在C++中无处不在，内存泄漏几乎在每个C++程序中都会发生，因此要想成为C++高手，内存管理一关是必须要过的，除非放弃C++，转到Java或者.NET，他们的内存管理基本是自动的，当然你也放弃了自由和对内存的支配权，还放弃了C++超绝的性能。本期专题将从内存管理、内存泄漏、内存回收这三个方面来探讨C++内存管理问题。 1 内存管理 伟大
BAT 大厂Java 面试题集锦之核心篇附参考答案
程序员光剑
11-05 1万+
核心篇数据结构与算法网路:TCP/IP,HTTP操作系统, 文件, shell, CPU, IO, epoll, 非阻塞IO,进程/线程/协程,锁HashMap, Co...
socket 客户端连接池实现
04-12
NULL 博文链接：https://smallbee.iteye.com/blog/1698708
(原创）当server碰到server，socket连接池简单实现-----第一次在csdn发表文章，多包涵：）
jsand的专栏
02-23 902
当我们在程序中启动了一个server,这个server需要跟另一个server（比如建立在老系统上的老的c程序）之间通讯，为了增加效率需要建立一个连接池的时候不妨考虑下我的解决方案，不足处清指正。1：SocketAdapter类，此类继承了socket，重载了socket类的close方法，目的是当用户关闭socket的时候，我们并不关闭它只是放在连接池内部。package com.taren
构建简单的socket连接池
weixin_30319097的博客
07-23 146
一开始，选用Vector<E>来存放连接。由于这个容器不是并发安全的，于是，每个方法都加一个synchronized来保持并发时的同步操作，并发效率很差，果断放弃。空余时间研究了下多线程的并发知识，决定用并发安全的阻塞队列（LinkedBlockingQueue<E>）,这个容器可以自动维护容量的大小，就免去了再起一个线程去维护线程池的大小。为了保证每个连接是可用的，为线程...
java socket连接池 实现
08-14
NULL 博文链接：https://516100981.iteye.com/blog/2314314
socket连接池
热门推荐
nokianasty的专栏
01-30 1万+
socket连接池  2011-06-16 20:40:54|  分类： 网络服务编程技术 |  标签： |字号大中小 订阅 socket连接池 SOCKET连接池原来注意过，但时间长了，对这个的了解有些乱，今天总结一下，趁着天气比较凉快，心情也比较舒畅。 SOCKET连接池产生，目的是为了减少内核在创建和销毁SOCKET时所产生的开销，一个两个的SOCKET的
浅谈 高并发 处理方案
m0_72758098的博客
04-22 931
分享一套我整理的面试干货，这份文档结合了我多年的面试官经验，站在面试官的角度来告诉你，面试官提的那些问题他最想听到你给他的回答是什么，分享出来帮助那些对前途感到迷茫的朋友。
浅谈Java项目日志记录和分析 (基于log4j介绍)
且听风吟_z
10-03 7397
一、前言 日志记录是应用程序运行中必不可少的一部分。具有良好格式和完备信息的日志记录可以在程序出现问题时帮助开发人员迅速地定位错误的根源。记录日志只是有效地利用日志的第一步，更重要的是如何对程序运行时产生的日志进行处理和分析。
面经准备（持续更新）
qq_40088655的博客
05-25 709
1. get和post的区别 GET 在浏览器回退时是无害的，而 POST 会再次提交请求。 GET 产生的 URL 地址可以被 Bookmark，而 POST 不可以。 GET 请求会被浏览器主动 cache，而 POST 不会，除非手动设置。 GET 请求只能进行 url 编码，而 POST 支持多种编码方式。 GET 请求参数会被完整保留在浏览器历史记录里，而 POST 中的参数不会被保留。 GET 请求在 URL 中传送的参数是有长度限制的，而 POST 么有。 对参数的
socket线程连接池实例
11-22
socket对象连接池实例，使用GenericObjectPool对象池。
socket池，socket
05-30
socket池，socket连接池，代码示例
java socket连接池
08-20
一个socket池模拟处理并发服务器
用Java实现socket连接池
weixin_35752233的博客
02-08 395
在Java中实现socket连接池可以使用第三方库来实现，比如Apache Common Pool或C3P0。也可以自己手写实现。 下面是使用Apache Common Pool实现的示例代码: // 创建连接池配置对象 GenericObjectPoolConfig config = new GenericObjectPoolConfig(); config.setMaxTotal(5); co...
Socket连接池设计
技术博客
04-28 2621
 技术要点·读取并解析xml配置文件·单例模式的使用·适配器模式的使用·JAVA的socket编程·JAVA的多线程·连接池的设计起因：由于我做的系统需要模拟短信发送功能，选定的是用socket通信来模拟。WEB部分发送短信时需要不断的建立socket连接，收发消息，断开连接。这样耗费是很大的，因为可能同时很多用户发短信，并且没发一条都要重复一次上述过程。起先想到了用单例模式。建立一个
使用Java实现socket连接池
weixin_35755823的博客
01-17 1040
实现Socket连接池可以使用Apache Commons Pool库中的GenericObjectPool类。首先需要实现一个工厂类，它将创建和销毁Socket连接。然后，使用GenericObjectPool类来创建一个连接池并维护连接。具体步骤如下: 创建一个工厂类，实现org.apache.commons.pool2.PooledObjectFactory接口，并重写create()、d...
如何创建和使用socket链接池
04-13 705
<!-- alimama_pid="mm_10249644_1605763_4929893"; alimama_titlecolor="707070"; alimama_descolor ="CCCCCC"; alimama_bgcolor="FFFFFF"; alimama_bordercolor="FFFFFF"; alimama_linkcolor="DADA
java实现socket连接池
最新发布
05-24
Java实现socket连接池，可以通过自定义连接池类来实现。下面是一个简单的示例： ``` import java.io.IOException; import java.net.Socket; import java.util.ArrayList; import java.util.List; public class ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

AI觉醒实战营

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值