JDBC | Chapter 6: simple use of database connection pool

One . Why use connection pools

Database connection is a key limited and expensive resource , This is especially prominent in multi-user web applications . A database connection object corresponds to a physical database connection , Each operation opens a physical connection , Close the connection after use , This results in poor performance of the system .

The solution to the database connection pool is to establish enough database connections when the application starts , These connections form a connection pool ( In short ： In a “ pool ” There are a lot of semi-finished database connection objects in it ), The application dynamically requests connections in the pool 、 Use and release . For more concurrent requests than the number of connections in the connection pool , You should queue in the request queue . And the application can be based on the utilization of connections in the pool , Dynamically increase or decrease the number of connections in the pool .

Connection pooling technology reuses as many memory consuming resources as possible , It saves a lot of memory , Improve the service efficiency of the server , Be able to support more customer service . By using the connection pool , Will greatly improve the efficiency of the program , meanwhile , We can monitor the number of database connections through its own management mechanism 、 Usage, etc .

Two . Usually use jdbc disadvantages

Steps to not use database connection pooling ：

1. TCP Three handshakes to establish a connection
2. MySQL Three handshakes for authentication
3. real SQL perform
4. MySQL The closing of the
5. TCP Four handshakes close

You can see , In order to carry out a clause SQL, But there's a lot more network interaction

advantage ：
Implement a simple
shortcoming ：

• The Internet IO More
• Database load is high
• Long response time and QPS The lower
• Applications frequently create and close connections , This results in more temporary objects ,GC frequent
• After closing the connection , There will be a lot of TIME_WAIT Of TCP state （ stay 2 individual MSL Then close ）

Use the connection pooling process

The first time I visited , Connection required . But after that visit , Will reuse the connection created before , Direct execution SQL sentence .

advantage ：

1. Less network overhead
2. There will be a substantial improvement in the performance of the system
3. There's no trouble TIME_WAIT state

The first time I visited , Connection required . But after that visit , Will reuse the connection created before , Direct execution SQL sentence .

advantage ：

1. Less network overhead
2. There will be a substantial improvement in the performance of the system
3. There's no trouble TIME_WAIT state

3、 ... and . How database connection pools work

The working principle of connection pool is mainly composed of three parts , Respectively

1. Establishment of connection pool
2. Connection management in connection pool
3. Closure of connection pool

First of all 、 Establishment of connection pool .

　　 Generally, when the system is initialized , The connection pool will be established according to the system configuration , And created several connection objects in the pool , So that you can get from the connection pool . Connections in a connection pool cannot be created or closed at will , This avoids the overhead caused by the random establishment and closure of connections .

Java Many container classes are provided in to facilitate the construction of connection pools , for example Vector、Stack etc. .

second 、 Connection pool management .

　　 Connection pool management policy is the core of connection pool mechanism , The allocation and release of connections in the connection pool have a great impact on the performance of the system . Its management strategy is ：

When a customer requests a database connection , First, check whether there are free connections in the connection pool , If there is an idle connection , Then assign the connection to the customer ; If there is no free connection , Check whether the current number of connections has reached the maximum number of connections , If not, re create a connection to the requesting customer ; If it is reached, wait according to the set maximum waiting time , If the maximum waiting time is exceeded , Throw an exception to the customer .

When the customer releases the database connection , First judge whether the number of references of the connection exceeds the specified value , If it exceeds, delete the connection from the connection pool , Otherwise, keep serving other customers .

This strategy ensures the effective reuse of database connections , Avoid frequent build ups 、 Release the system resource overhead caused by connection .

Third 、 Closure of connection pool .

When the application exits , Close all connections in the connection pool , Release connection pool related resources , This process is just the opposite of creating .

Four . Points to note about connection pooling

1、 Concurrency issues

In order to make the connection management service have the greatest commonality , You have to think about a multithreaded environment , That is, concurrency .

This problem is relatively easy to solve , Because each language itself provides support for concurrency management, such as java,c# wait , Use synchronized(java)lock(C#) Keyword to ensure that threads are synchronized .

2、 Transaction processing

We know , Transactions are atomic , At this point, the operation of the database is required to comply with “ALL-OR-NOTHING” principle , That is, for a group SQL You can either do it all , Or not at all .

We know when 2 Threads share a connection Connection object , And each has its own business to deal with , It's a big headache for connection pooling , Because even if Connection Class provides corresponding transaction support , However, we are still not sure that the database operation corresponds to that transaction , It's because we have ２ It is caused by two threads operating on transactions .

For this purpose, we can use each transaction to exclusive one connection , Although this method is a bit wasteful of connection pool resources, it can greatly reduce the complexity of transaction management .

3、 Allocation and release of connection pool

Allocation and release of connection pool , It has a great influence on the performance of the system . Reasonable distribution and release , It can improve the reusability of the connection , This reduces the overhead of establishing new connections , At the same time, it can also speed up the access speed of users .

For connection management, a List. That is, put all the created connections into the List Unified management in China . Whenever a user requests a connection , The system checks this List Is there any connection that can be assigned in . If so, assign him the most suitable connection , If not, throw an exception to the user .

４、 Configuration and maintenance of connection pool

How many connections should be placed in the connection pool , To optimize the performance of the system ？

The system can set the minimum number of connections （minConnection） And maximum connections （maxConnection） And other parameters to control the connections in the connection pool . For example , The minimum number of connections is the number of connections created by the connection pool at system startup . If you create too many , The system starts slowly , However, the response speed of the system will be very fast after creation ; If you create too few , The system starts up very quickly , The response is slow . such , It can be used during development , Set a small minimum number of connections , It will be developed quickly , When the system is actually used, a larger , Because it is faster to visit customers . The maximum number of connections is the maximum number of connections allowed in the connection pool , How much is the specific setting , It depends on the number of visits to the system , It can be obtained from the software requirements .

How to ensure the minimum number of connections in the connection pool ？ There are two strategies, dynamic and static . Dynamic means to detect the connection pool every certain time , If the number of connections is less than the minimum number of connections , Then add the corresponding number of new connections , To ensure the normal operation of the connection pool . Static is to check if there are not enough idle connections .

5、 ... and . Use of database connection pool

durid

package cn.soboys.kenx.datasource;

import com.alibaba.druid.pool.DruidDataSource;
import com.alibaba.druid.pool.DruidDataSourceFactory;

import javax.sql.DataSource;
import java.io.FileInputStream;
import java.io.IOException;
import java.sql.Connection;
import java.util.Properties;

/* * jdbc  Through data connection pool  Druid  Get database connection  */
public class DruidDatasource {

    // Configure through the properties file , The data source factory does not need to manually configure a single property 
    public Connection getConnectionByDuridPoolProperties() {
        Properties prop = new Properties();
        try {
            prop.load(new FileInputStream("src/main/resources/durid.properties"));
            //  Get connection pool object 
            DataSource dataSource = DruidDataSourceFactory.createDataSource(prop);
            System.out.println(" Database connection successful ");
            return dataSource.getConnection();
        } catch (IOException e) {
            e.printStackTrace();
            return null;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    // Through code configuration 
    public Connection getConnectionByDBCPPoolCode() {

        try {
            DruidDataSource bds=new DruidDataSource();
            bds.setUrl("jdbc:mysql://localhost:3306/kenx_test?characterEncoding=utf-8");
            bds.setDriverClassName("com.mysql.cj.jdbc.Driver");
            bds.setUsername("root");
            bds.setPassword("root");
            bds.setInitialSize(5);
            Connection conn = bds.getConnection();
            System.out.println(" Database connection successful ");
            return conn;
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }

    }
}

Basically, it is completely quoted from

JDBC | Chapter vii. : JDBC Database connection pool is simple to use - kenx - JDBC | Chapter vii. : JDBC Database connection pool is simple to use - kenx - Blog Garden