FastDFS连接池报错

fy971676038

使用FastDFS报错，当删除或上传超过8000多文件时出现错误
java.net.SocketException: No buffer space available (maximum connections reached?): connect
        at java.net.DualStackPlainSocketImpl.connect0(Native Method)
        at java.net.DualStackPlainSocketImpl.socketConnect(DualStackPlainSocketImpl.java:73)
        at java.net.AbstractPlainSocketImpl.doConnect(AbstractPlainSocketImpl.java:339)
        at java.net.AbstractPlainSocketImpl.connectToAddress(AbstractPlainSocketImpl.java:200)
        at java.net.AbstractPlainSocketImpl.connect(AbstractPlainSocketImpl.java:182)
        at java.net.PlainSocketImpl.connect(PlainSocketImpl.java:157)
        at java.net.SocksSocketImpl.connect(SocksSocketImpl.java:391)
        at java.net.Socket.connect(Socket.java:579)
        at org.csource.fastdfs.TrackerGroup.getConnection(TrackerGroup.java:47)
        at org.csource.fastdfs.TrackerGroup.getConnection(TrackerGroup.java:89)
        at org.csource.fastdfs.TrackerClient.getConnection(TrackerClient.java:5
        at org.csource.fastdfs.TrackerClient.getStorages(TrackerClient.java:423)
        at org.csource.fastdfs.TrackerClient.getUpdateStorage(TrackerClient.java:373)
        at org.csource.fastdfs.StorageClient.newUpdatableStorageConnection(StorageClient.java:1986)
        at org.csource.fastdfs.StorageClient.delete_file(StorageClient.java:1107)
        at com.ninemax.bcm.nosqldb.fastdfs.dao.impl.FileClientImpl.delete(FileClientImpl.java:87)
        at com.ninemax.bcm.nosqldb.fastdfs.dao.impl.FileClientImpl.deletedFile(FileClientImpl.java:26)
        at com.ninemax.module.db.nosqldb.dao.storage.impl.SourceDataFastDFSFileDaoImpl.deleteFileByRepositoryIds(SourceDataFastDFSFileDaoImpl.java:257)
        at com.ninemax.module.storage.filedata.iface.impl.FileDataRecordsCallableImpl.init(FileDataRecordsCallableImpl.java:11
        at com.ninemax.module.storage.filedata.main.Main.main(Main.java:14)
connect to server 168.160.24.37:22122 fail


连接池代码如下：
import java.io.IOException;
import java.net.InetSocketAddress;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.ConcurrentHashMap;

import org.csource.fastdfs.ClientGlobal;
import org.csource.fastdfs.StorageClient1;
import org.csource.fastdfs.StorageServer;
import org.csource.fastdfs.TrackerClient;
import org.csource.fastdfs.TrackerGroup;
import org.csource.fastdfs.TrackerServer;

public class ConnectionPool {

        // 最大连接数,可以写配置文件
        private int size = 100;
        // 被使用的连接
        private ConcurrentHashMap<StorageClient1, Object> busyConnectionPool = null;
        // 空闲的连接
        private ArrayBlockingQueue<StorageClient1> idleConnectionPool = null;

        private Object obj = new Object();

        private static ConnectionPool instance = new ConnectionPool();

        public static ConnectionPool getConnectionPool() {
                return instance;
        }

        // 取出连接
        public StorageClient1 checkout(int waitTime) {
                StorageClient1 storageClient1 = null;
                try {
                        storageClient1 = idleConnectionPool.take();
//                                        .poll(waitTime, TimeUnit.SECONDS);
                        // System.out.println(storageClient1);
                        if (storageClient1 != null) {
                                busyConnectionPool.put(storageClient1, obj);
                        }
                } catch (InterruptedException e) {
                        storageClient1 = null;
//                        e.printStackTrace();
                }
                return storageClient1;
        }

        // 回收连接
        public void checkin(StorageClient1 storageClient1) {
                if (busyConnectionPool.remove(storageClient1) != null) {
                        idleConnectionPool.add(storageClient1);
                }
        }

        // 如果连接无效则抛弃，新建连接来补充到池里
        public void drop(StorageClient1 storageClient1) {
                if (busyConnectionPool.remove(storageClient1) != null) {
                        TrackerServer trackerServer = null;
                        TrackerClient trackerClient = new TrackerClient();
                        try {
                                trackerServer = trackerClient.getConnection();
                               
                                StorageClient1 newStorageClient1 = new StorageClient1(
                                                trackerServer, null);
                                idleConnectionPool.add(newStorageClient1);
                                System.out.println("idleConnectionPool------drop----- :connection +1";
                        } catch (IOException e) {
                                e.printStackTrace();
                        } finally {
                                if (trackerServer != null) {
                                        try {
                                                trackerServer.close();
                                        } catch (IOException e) {
                                                e.printStackTrace();
                                        }
                                }
                        }
                }
        }

        // 单例
        private ConnectionPool() {
                busyConnectionPool = new ConcurrentHashMap<StorageClient1, Object>();
                idleConnectionPool = new ArrayBlockingQueue<StorageClient1>(size);
                init(size);
        }

        // 初始化连接池
        private void init(int size) {
                initClientGlobal();
                TrackerServer trackerServer = null;
                try {
                        TrackerClient trackerClient = new TrackerClient();
                        // 只需要一个tracker server连接
                        trackerServer = trackerClient.getConnection();
                        StorageServer storageServer = null;
                        StorageClient1 storageClient1 = null;
                        for (int i = 0; i < size; i++) {
                                storageClient1 = new StorageClient1(trackerServer,
                                                storageServer);
                                idleConnectionPool.add(storageClient1);
                                System.out.println("idleConnectionPool--------init------- :connection +1";
                        }

                } catch (IOException e) {
                        e.printStackTrace();
                } finally {
                        if (trackerServer != null) {
                                try {
                                        trackerServer.close();
                                } catch (IOException e) {
                                        e.printStackTrace();
                                }
                        }
                }
        }

        // 初始化客户端
        private void initClientGlobal() {
                // 连接超时时间
                ClientGlobal.setG_connect_timeout(2000);
                // 网络超时时间
                ClientGlobal.setG_network_timeout(3000);
                ClientGlobal.setG_anti_steal_token(false);
                // 字符集
                ClientGlobal.setG_charset("UTF-8";
                ClientGlobal.setG_secret_key(null);
                // HTTP访问服务的端口号
                ClientGlobal.setG_tracker_http_port(8080);

                InetSocketAddress[] trackerServers = new InetSocketAddress[2];
                trackerServers[0] = new InetSocketAddress("168.160.24.37", 22122);
                trackerServers[1] = new InetSocketAddress("168.160.24.37", 22122);
                TrackerGroup trackerGroup = new TrackerGroup(trackerServers);
                // tracker server 集群
                ClientGlobal.setG_tracker_group(trackerGroup);
        }

}

god_cui

这种简陋的连接池没有心跳检测和恢复连接等功能，假如你的client与tracker的连接断了，你没有检测和恢复功能，所以报错我觉得很正常。
我现在正在考虑做一个健壮的连接池，有恢复与挂起、心跳检测，超时回收等等功能，
大家一起学习吧，
余大有什么好的建议呢？

各位大侠请多指教。