English
English
When building high-concurrency web applications, the overhead of establishing database connections becomes a significant performance bottleneck. Creating a new connection for every request not only wastes resources but can also lead to frequent disruptions. To address this, PHP provides a mechanism for persistent database connections. The connect() function, in certain extensions like MySQL and PostgreSQL, can be used in a persistent manner to effectively boost system performance and stability.
A persistent connection means that after a request ends, the PHP script does not close the database connection. Instead, the connection is kept in a pool for reuse in subsequent requests. This avoids the repeated “connect-disconnect-reconnect” cycle, reducing server load.
Using MySQL as an example, both the mysqli and PDO extensions in PHP can be configured to use persistent connections. Here's an example using mysqli:
<?php
$host = 'p:localhost'; // Note the 'p:' prefix indicates a persistent connection
$user = 'db_user';
$password = 'db_pass';
$database = 'example_db';
<p>$conn = new mysqli($host, $user, $password, $database);</p>
<p>if ($conn->connect_error) {<br>
die("Connection failed: " . $conn->connect_error);<br>
}</p>
<p>echo "Persistent connection established!";<br>
?><br>
In the code above, by adding the p: prefix to the hostname, mysqli attempts to establish a persistent connection. If there’s an available connection in the pool, it will be reused; otherwise, a new connection will be created.
PDO offers a more elegant way to set up persistent connections by simply configuring an option:
<?php
$dsn = 'mysql:host=localhost;dbname=example_db';
$user = 'db_user';
$password = 'db_pass';
<p>$options = [<br>
PDO::ATTR_PERSISTENT => true,<br>
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,<br>
];</p>
<p>try {<br>
$pdo = new PDO($dsn, $user, $password, $options);<br>
echo "PDO persistent connection established!";<br>
} catch (PDOException $e) {<br>
echo "Connection failed: " . $e->getMessage();<br>
}<br>
?><br>
With PDO::ATTR_PERSISTENT, enabling persistent connections is straightforward and doesn’t require modifying the hostname.
Performance Boost: Eliminates the CPU and memory overhead of frequent connection creation.
Faster Response: Operations can proceed almost instantly with existing connections.
Resource Reuse: Multiple requests can share connection resources, reducing pressure on the database server.
While persistent connections offer many benefits, there are some potential issues to be mindful of:
Risk of Connection Leaks: If transactions or statements aren't handled properly, resources may accumulate within a connection.
Connection State Contamination: Since connections are reused across requests, it’s crucial to reset the state at the start of each request.
Connection Limit Saturation: Persistent connections are harder to release and can exhaust the maximum allowed connections on the database. It’s advisable to configure connection limits appropriately at the database level.
Suppose the remote database address is db.m66.net and you want to establish a persistent connection using PDO:
<?php
$dsn = 'mysql:host=db.m66.net;dbname=example_db';
$user = 'remote_user';
$password = 'remote_pass';
<p>$options = [<br>
PDO::ATTR_PERSISTENT => true,<br>
PDO::ATTR_ERRMODE => PDO::ERRMODE_EXCEPTION,<br>
];</p>
<p>try {<br>
$pdo = new PDO($dsn, $user, $password, $options);<br>
echo "Successfully connected to the remote database!";<br>
} catch (PDOException $e) {<br>
echo "Connection failed: " . $e->getMessage();<br>
}<br>
?><br>
By using the p: prefix in mysqli or enabling PDO::ATTR_PERSISTENT in PDO, PHP developers can easily implement persistent database connections. While this approach significantly improves performance and response time, it must be paired with disciplined resource management to keep connections secure and clean. Monitoring connection usage and application health is a crucial step in ensuring stable system operations.
