Detailed explanation of the steps to implement mysql connection pool effect in php

This time I will bring you a detailed explanation of the steps to implement the mysql connection pool effect in php. What are the precautions for php to implement the mysql connection pool effect. The following is a practical case, let's take a look.

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 bug, the project sent a large number of connection requests to mysql one night, and at the same time, there was a problem with the dns of the mysql server. , causing the reverse solution to time out. 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.

I believe you have mastered the method after reading the case in this article. For more exciting information, please pay attention to other related articles on the php Chinese website!

Recommended reading:

Detailed explanation of the steps of implementing multiple linear regression simulation curve algorithm in PHP

Access array elements in double quotes in php How to handle error reporting

The above is the detailed content of Detailed explanation of the steps to implement mysql connection pool effect in php. For more information, please follow other related articles on the PHP Chinese website!