【进阶之路】和南橘一起探索连接池（一）_连接池是否可以设置tls

一、连接池的定义

什么叫连接池？顾名思义，连接池就是将应用所需的连接对象放在池中，每次访问时从池中获取，使用完毕再放回池中，以达到连接复用的目的。连接池和线程池很像，都是为了减少连接对象在创建、销毁连接过程中不必要消耗的资源。

大家接触最多的连接池、大概是数据库连接或者tomcat连接池，C3P0、DBCP、Tomcat Jdbc Pool、BoneCP、Druid等。这些连接池的目的都非常的纯粹，即在服务启动的时候，预先生成若干条连接，每当有请求过来，就从中取出一个，执行操作，执行完成后再放回，从而避免反复的建立和销毁连接，以提升性能。

连接池性能对比

实际在微服务中，连接池是非常重要的组件，因为服务间需要建立连接通信，通过连接池可以极大地提高服务间的通信性能。

因此，我们只要建立多条连接，用一个数组维护多条连接就行了；如果使用一条连接，那么从数组里拿出这条连接，使用完再放入数组即可。当数组为空时，只要建立新的连接就可以了。

二、自定义连接池

具体的实现可以参考我下文实现的代码。这个连接池拥有了几个基本数据。

• maxIdleConns 最大空闲连接数,这个值相当于线程池里的核心线程数、与线程池不一样的是，配置了最大空闲数后，连接池的连接将会长期保持。这个值的设置很有讲究，需要结合后端服务的连接承载能力设置。

• currentCount 当前使用数目，类似于核心线程数到最短线程数之前的这个值。

• maxIdCount 最大连接数，代表着连接池的上限。

• ttls 连接的过期时间，这个时间线程池中也有，如果连接都为空闲连接，则不会进行过期处理。

public class MyPool {

    // 最大连接数 
    private int maxIdCount;
    //记录当前使用 的连接数目
    private int currentCount ;
    //初始化线程数、最大空闲连接数
    private int maxIdleConns;
	// 多久后连接会断开，很多连接池会在一定时间后断开连接，然后将新鲜的连接放入连接池
    private int ttls;

    //我们用LinkedList来定义一个连接池
    private LinkedList<Connections> connectionPool;

    public MyPool(int maxIdleConns, int currentCount,int maxIdCount,int ttls) {
        this.maxIdleConns = maxIdleConns;
        this.currentCount = currentCount;
        this.maxIdCount =maxIdCount;
        this.ttls=ttls;
        this.connectionPool = new LinkedList<Connections>();

        for(int i=0;i<maxIdleConns;i++){
            connectionPool.add(createConnection());
        }
    }
    /**
     * 建立一个链接
     * @return  Connection
     */
    public    Connections createConnection(){
        try {

            Class.forName("com.mysql.jdbc.Driver");
            return new Connections(DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "root"), DateUtil.getCurrTime());
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 先判断连接池中是否有连接，如果有直接使用，如果没有连接，
     * 则先判断当前的连接是否达到最大连接数，达到的话 抛出异常，没有达到最大连接 则创建连接
     * @return
     */
    public Connections getConnection(){
        //1.判断，池中若有连接直接使用
        if(connectionPool.size()>0){
            //把这个链接移出集合并返回当前连接对象。
            currentCount++;
            return connectionPool.removeFirst();

        }
        //如果池中没有连接而且没有达到最大连接数目；则创建连接
        if(currentCount>=maxIdleConns && currentCount<maxIdCount){
            currentCount++;
            //创建一个新的连接
            return createConnection();
        }
        //判断是否达到最大连接数，达到则抛出异常
        System.out.println();
        throw new RuntimeException("当前连接已经达到最大连接数！");
    }


    /**
     * 把连接放回连接池（集合）中。如果池中连接数小初始化连接数目就放回池中，其他则关闭连接。
     * @param conn
     */
    public void releaseConnection(Connections conn){
        //判断池中的数目如果小于初始化连接就放回连接池中
        //判断连接池中的剩余数目是否<连接池初始化数目   如果为真 则放回连接池
        if(currentCount<=maxIdCount){
            //放回连接池
            connectionPool.addLast(conn);
            //当前连接-1
            currentCount--;

        }else{
            //关闭连接
            try {
                conn.connection.close();
                currentCount--;
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    /**
     * 清除全部超时连接
     * 初始化线程数无需释放
     * @param connectionPool
     */
    public void release(LinkedList<Connections> connectionPool){
        if (connectionPool.size()<1||currentCount==0){
            return;
        }
        if ( ttls<(DateUtil.getCurrTime()-connectionPool.getFirst().getTtl())){
            Connections conn = connectionPool.getFirst();
            //当前连接-1
            currentCount--;
            connectionPool.removeFirst();
            //关闭连接
            try {
                conn.connection.close();
                currentCount--;
            } catch (SQLException e) {
                e.printStackTrace();
            }
            release(connectionPool);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

三、连接池需要的问题

1、并发问题

上面的代码只是我简单实现了一下连接池，但是为了使连接管理服务具有最大的通用性，必须考虑多线程环境，即并发问题。在java中，有各种锁的机制能够解决连接池的并发问题。

2、连接池大小的设置

如果设置得太大，假如设置 1000，始发集群有 100 台机器，那么就会建立 10w 的持久连接，这对后端服务的压力可想而知。但也不能设置得太小。

如果连接池满了，就会建立新的连接，不断建立的新连接会耗光后端服务的资源。

新建立的连接在用完之后，有两种选择——连接池有余量的情况会放入连接池，反之会直接丢弃，这种情况在瞬间很容易出现，连接池持续瞬间被空闲连接占满（最大空闲连接数的叫法也由此得来），导致新连接无法放回连接池，进而丢弃，这样就会形成建立连接—用完丢弃的恶性循环，连接池的作用也就消失了。对于HTTP请求的连接池来说，所有的连接都退化成了短连接。

实际上连接并没有长短之分，只是取决于传输完数据后是否断开。那么为什么会有长短连接的叫法呢？这是因为 HTTP 协议多用于 Web 中，Web 的交互方式多是一来一回的模式，这样的应用场景下，不需要服务端推数据，所以建立连接后立即释放也是完全可以的。

3、连接池的分配与释放

连接池的分配与释放，对系统的性能有很大的影响。合理的分配与释放，可以提高连接的复用度，从而降低建立新连接的开销，同时还可以加快用户的访问速度。
我们这个连接池是使用LinkedList来实现的，主要的目的是考虑到过期时间。在链表中，前面连接的持续时间一定高于后面的连接，也可以减少连接的轮循时间。

大家好，我是练习java两年半时间的南橘，下面是我的微信，需要之前的导图或者想互相交流经验的小伙伴可以一起互相交流哦。