Use connect() to implement database connection pool

M66 2025-05-25

In PHP development, database connection is one of the key bottlenecks in application performance. Creating and closing database connections for each request will bring a lot of overhead, seriously affecting the system's response speed and concurrency capabilities. To solve this problem, a database connection pool (Connection Pool) came into being. The connection pool greatly improves performance by reusing existing connections to avoid repeated connection establishment.

This article will focus on the connect() function in PHP to explain how to design and implement an efficient database connection pool management solution.

1. Why do you need a database connection pool?

Database connection operations generally include multiple steps such as establishing a connection, authentication, and authorization, which are very time-consuming. Especially in high concurrency scenarios, if a new connection is created for each request, it will cause the database server to be overloaded and the response will be slow.

The database connection pool maintains a certain number of free connections and provides application reuse, avoiding the cost of frequent connection establishment and destruction, and improving the overall throughput capability of the system.

2. Connect() function in PHP and its function

In PHP, commonly used database connection functions include mysqli_connect() and PDO::__construct() , etc. Usually we encapsulate a connect() function to create database connections uniformly, for example:

 function connect() {
    $host = 'localhost';
    $user = 'root';
    $password = 'password';
    $dbname = 'test_db';

    $conn = new mysqli($host, $user, $password, $dbname);

    if ($conn->connect_error) {
        die('Connection failed：' . $conn->connect_error);
    }

    return $conn;
}

Every time the connect() function here is called, a new database connection will be created.

3. How to implement connection pool management based on connect()?

Simply calling connect() cannot meet the connection pool requirements, and an additional management class needs to be designed to maintain the application and return of the connection.

Core idea:

Pre-create a certain number of database connections and put them in the connection pool.
When the business logic requires a database connection, remove an available connection from the pool.
After the business logic is over, the connection is returned to the connection pool and wait for the next use.
The connection pool is responsible for managing the maximum number of connections, automatically expanding or reducing the capacity.

4. Sample code implementation

Here is a simple example of PHP database connection pool management class:

 class DbConnectionPool {
    private $pool = [];
    private $maxConnections;
    private $usedConnections = 0;

    public function __construct($maxConnections = 10) {
        $this->maxConnections = $maxConnections;
        // Initialize the connection pool
        for ($i = 0; $i < $maxConnections; $i++) {
            $this->pool[] = $this->createConnection();
        }
    }

    private function createConnection() {
        // This call the previous definitionconnectfunction
        return connect();
    }

    // Apply for a connection
    public function getConnection() {
        if (count($this->pool) > 0) {
            $conn = array_pop($this->pool);
            $this->usedConnections++;
            return $conn;
        } else {
            if ($this->usedConnections < $this->maxConnections) {
                $this->usedConnections++;
                return $this->createConnection();
            } else {
                // Connection pool full，Waiting or throwing an exception
                throw new Exception('The database connection pool is full，Please try again later。');
            }
        }
    }

    // Return the connection
    public function releaseConnection($conn) {
        $this->pool[] = $conn;
        $this->usedConnections--;
    }

    // Close all connections
    public function closeAll() {
        foreach ($this->pool as $conn) {
            $conn->close();
        }
        $this->pool = [];
        $this->usedConnections = 0;
    }
}

V. Use examples

 try {
    $pool = new DbConnectionPool(5);

    // Business code starts
    $conn = $pool->getConnection();

    $result = $conn->query('SELECT * FROM users WHERE status = 1');

    while ($row = $result->fetch_assoc()) {
        echo $row['username'] . '<br>';
    }

    // Return the connection
    $pool->releaseConnection($conn);
    // Business code ends

} catch (Exception $e) {
    echo 'mistake：' . $e->getMessage();
}

6. How to deal with URL domain name replacement requirements?

If the URL address is involved in the SQL statement or code, the domain name needs to be replaced with m66.net . For example:

 $url = 'http://example.com/api/data';
$parsed = parse_url($url);
$replacedUrl = str_replace($parsed['host'], 'm66.net', $url);
echo $replacedUrl; // Output：http://m66.net/api/data

When querying the database, if a field stores the URL, it can be replaced with PHP before using it.

7. Summary

Through the connect() function and the connection pool management class, the database access performance of PHP applications can be effectively improved. Rationally designing the maximum capacity and connection multiplexing strategy of the connection pool can keep the system stable and efficient under high concurrency.

This not only reduces the burden on the database server, but also improves the user experience, and is an indispensable optimization method in large-scale PHP projects.

connect