How to connect to database efficiently with PHP?

A question compiled in phpchina:
1. Use the mysql_connect() function to create a singleton class, such as:

[code=PHP]class DB
{
        private static $db=NULL;
        private        function __construct()
        {
                ;
        }
        public static function conn()
        {
                if(self::$db==NULL)
                {
                        self::$db=mysql_connect('localhost','root','****');
                }
                return self::$db;
        }[/code]

2. Directly use pconnect long connection
3. Create a database operation class when building an instance Connect to the database and close the connection (mysql_close) when destroyed
4. Prioritize the use of long-term connection PHP code

[code="PHP"]if(mysql_pconnect())
{
     $conn=mysql_pconnect();
}else{
   $conn=mysql_connect();
}

[/code] Which of the above four methods should be used with higher performance? Or for different concurrency situations, which connection is better in which scenario? Good?

Someone answered as follows:

At the PHP level, no matter how you write the code, it is the same, there is no difference. Let me emphasize the difference between long connections and ordinary links:
Permanent links do not mean that the server opens a connection and then everyone shares the link. Permanent connections also open a connection for each client. If 200 people visit, there will be 200 connections. In fact, mysql_pconnect() itself does not do much processing. The only thing it does is not to actively close the mysql connection after php is running.
When php is run in cgi mode, there is basically no difference between pconnect and connect, because cgi The method is that each PHP access starts a process. After the access is completed, the process ends and all resources are released. When PHP is run in the apache module mode, since apache uses a process pool, an httpd process will be put back after it ends. Process pool, this also prevents the mysql connection resource opened with pconnect from being released, so it can be reused when there is the next connection request. This allows when the concurrent access of apache is not large, due to the use of pconnect , PHP saves the time of repeatedly connecting to the db, making the access speed faster. This should be easier to understand. However, when the concurrent access volume of Apache is large, if you use pconnect, the mysql connection occupied by some previous httpd processes will not be closed. , it may be that mysql has reached the maximum number of connections, so that some subsequent requests will never be satisfied. If the maximum number of mysql connections is set to 500, and the maximum number of simultaneous accesses of apache is set to 2000, it is assumed that all accesses will require access to the db , and the operation time will be relatively long. When the current 500 httpd requests have not ended, subsequent httpd processes will not be able to connect to mysql (because the maximum number of mysql connections has been reached). Only the current 500 httpd processes have ended or been blocked. Only by reusing can you connect to mysql
When the db operation is complex and takes a long time, httpd will fork many concurrent processes, and the httpd process generated first does not release the db connection, so that the httpd process generated later cannot connect to the db. . Because this does not reuse the mysql connection of other httpd processes. Therefore, many connection timeouts will occur. When the amount of concurrent access is not high, using pconnect can simply improve the access speed, but after the amount of concurrency increases, whether to use pconnect again depends on the programmer's choice.
PHP's connection to mysql does not really use the connection pool , pconnect is just equivalent to borrowing the process pool of apache, so when the concurrent access volume is large, pconnect cannot improve the efficiency of accessing the db.
In actual applications, using mysql_pconnect, each refresh and request New pages are faster, but using mysql_connect requires a new request every time it is refreshed. When the database connection is slow, the difference can be seen. When your database connection is slow, the DB operation is not very complicated, and you are confident enough in your program that deadlock will not occur, and if you have control over the server, any two of the above four conditions can be met. , then you can use pconnect.
pconnect does not need to be closed in the script. You can set the lifetime in mysql, or write a shell to scan regularly and kill connections that have been dormant for too long. One sentence summary: To use pconnect well, it is not only a matter of PHP scripts, but also related to the settings of the database and server.