PHP implements the effect of mysql connection pool

This article mainly introduces the PHP code to achieve the effect of mysql connection pool. Friends who need it can refer to

Loop to obtain connections from the mysql connection pool without repeatedly creating new connections.

Reference configuration modification: You can refer to the following article

Prevent the number of visits from being too large and filling up the number of connections

 true); for ($i=0; $i < self::POOLSIZE; $i++) { $connection = new PDO("mysql:dbname=$db;host=$host", $username, $password); // sleep(3); array_push($this->_pools, $connection); } } //从数据库连接池中获取一个数据库链接资源 public function getConnection() { echo 'get' . count($this->_pools) . "
"; if (count($this->_pools) > 0) { $one = array_pop($this->_pools); echo 'getAfter' . count($this->_pools) . "
"; return $one; } else { throw new ErrorException ( "数据库连接池中已无链接资源，请稍后重试!" ); } } //将用完的数据库链接资源放回到数据库连接池 public function release($conn) { echo 'release' . count($this->_pools) . "
"; if (count($this->_pools) >= self::POOLSIZE) { throw new ErrorException ( "数据库连接池已满!" ); } else { array_push($this->_pools, $conn); // $conn = null; echo 'releaseAfter' . count($this->_pools) . "
"; } } public function query($sql) { try { $conn = $this->getConnection(); $res = $conn->query($sql); $this->release($conn); return $res; } catch (ErrorException $e) { print 'error:' . $e->getMessage(); die; } } public function queryAll($sql) { try { $conn = $this->getConnection(); $sth = $conn->prepare($sql); $sth->execute(); $result = $sth->fetchAll(); return $result; } catch (PDOException $e) { print 'error:' . $e->getMessage(); die; } } }

Call this in another file

query($sql); // var_dump($res) . PHP_EOL; }

How to use the connection pool of ThinkPHP to connect to MySQL

Because of a small The bug caused the project to send a large number of connection requests to mysql one night. At the same time, there was a problem with the dns of the mysql server, causing the anti-resolution timeout. Finally, the mysql server was dragged alive.

Finally the bug was fixed and we studied the method of increasing mysql connection pool.

After searching in the past two days, I found that there is no documentation related to connection pooling in the ThinkPHP documentation. So I studied the code myself.

First of all: There are three commonly used mysql extension libraries in PHP: mysql, mysqli, pdo_mysql.

* mysqli does not support connection pooling.
* pdo_mysql is supported, however, thinkPHP's pdo extension does not support mysql, only supports: 'MSSQL', 'ORACLE', 'Ibase', 'OCI'. (See line 59 of Pdo.class.php)

* mysql support, through the method: mysql_pconnect. (For specific parameters, please see the official php documentation)

1 The way to enable ThinkPHP to enable long connections is:

class BaseMysql extends Model { protected $connection = array( 'db_type' => 'mysql', 'db_user' => '***', 'db_pwd' => '*******', 'db_host' => '*******', 'db_port' => '3306', 'db_name' => 'custom', 'db_params' => array('persist' => true), ); }

If you think that everything will be fine if you configure this, you are totally wrong.

2 mysql -> my.cnf Modify configuration:
[mysqld]

interactive_timeout =60 // Expiration time of interactive connection (mysql-client).
wait_timeout =30 //Expiration time of long connection. This must be changed! The default is 8 hours. If the request volume is large, the number of connections will be full soon.
max_connections = 100 //The maximum number of connections can be considered as the size of the connection pool

3 php.ini modification:
[MySql]
mysql.allow_persistent = On
mysql. max_persistent = 99 // Must be less than the maximum number of connections configured by mysql
mysql.max_links = 99

4 If the webserver is apache, keep-alive needs to be enabled. Otherwise, once the request exits, the long connection cannot be reused.
Webserver is the case of nginx:
pm = dynamic // Some sub-processes are started by default to handle http requests.
pm.max_children // Maximum number of child processes. This configuration should be smaller than mysql's max_connections.

5 If you find that it still cannot be used, please check whether the keepalive of the operating system is enabled.

Overview:

Keep-alive and database long connection need to be enabled at the same time, otherwise the long connection will occupy the number of mysql connection resources in vain and cannot be reused.
In the case of nginx php-fpm, the long connection between the php-fpm sub-process and mysql is actually maintained. Which php-fpm sub-process the front-end http request is assigned to, the sub-process will reuse its long connection with mysql.

The above is the result of a whole day of research. Please point out any imperfections and thank you in advance!

The above is the entire content of this article. Thank you everyone for reading. For more related content, please pay attention to the PHP Chinese website!

Related recommendations:

thinkphp3.2.3 version database addition, deletion, modification and query implementation code

The above is the detailed content of PHP implements the effect of mysql connection pool. For more information, please follow other related articles on the PHP Chinese website!