How do all Swoole coroutines share the same database connection?

With the rapid development of the Internet and the continuous growth of data volume, in order to ensure the high performance and scalability of applications, developers have begun to widely use asynchronous programming frameworks. Since its launch, Swoole has become a pioneer in PHP asynchronous programming and has been favored by more and more developers. Swoole provides full coroutine support, which can greatly improve the application's concurrent request processing capabilities. In some application scenarios, different coroutines need to share the same database connection. In this case, Swoole coroutine sharing technology needs to be used.

The essence of Swoole coroutine sharing technology is to allocate database connections in the connection pool to the coroutine for use. After the coroutine is used, the connection is returned to the connection pool. The advantage of this is that it avoids each coroutine having to connect to the database, thereby reducing the connection overhead and improving application performance. In a multi-coroutine environment, sharing database connections in the same connection pool can also avoid being limited by the number of connections.

Let’s take a look at how Swoole implements coroutines to share the same database connection.

Step One: Install Swoole Extension

Swoole official website provides an installation tutorial. It only takes a few simple steps to complete the installation. After the installation is complete, you need to add the swoole expansion configuration in the php.ini file:

extension=swoole.so

Step 2: Create a connection pool

In Swoole, the connection pool is a very important concept , its function is to increase the reusability of database connections. The connection pool will maintain the persistence of the connection to avoid frequent connections to the database and ensure the efficiency of the application. We can use Swoole's connection pool class SwooleCoroutineMySQLPool to create a connection pool object.

 '127.0.0.1',
    'port' => 3306,
    'user' => 'root',
    'password' => '',
    'database' => 'test_db',
    'charset' => 'utf8mb4',
    'timeout' => 30,
    'strict_type' => true,
    'fetch_mode' => true,
    'max_idle_time' => 3,
    'max_object_num' => 20,
];

$pool = new SwooleCoroutineMySQLPool($dbconfig);

Connection pool configuration item description:

• host: The host address of the database connection
• port: The port number of the database connection
• user: User name for database connection
• password: Password for database connection
• database: Database name used by default
• charset: Encoding used for connection
• timeout: Connection timeout period
• strict_type: Whether to enable strict mode
• fetch_mode: Whether to use custom data acquisition method
• max_idle_time: Maximum idle time of connection
• max_object_num: The maximum number of connections that exist in the connection pool

Step 3: Obtain the connection object

After creating the connection pool, you need to obtain the database connection object in each coroutine. In Swoole, you can obtain the database connection object through the SwooleCoroutineMySQLPool->get() method.

get();
    // 查询操作
    $result = $conn->query('SELECT * FROM users');
    // 归还连接
    $pool->put($conn);
});

Note: Each coroutine must obtain the connection object through the connection pool to avoid multiple coroutines operating the same connection object at the same time.

Step 4: Close the connection

After the coroutine has finished using the connection object, it should be returned to the connection pool. In Swoole, the connection can be returned to the connection pool through SwooleCoroutineMySQLPool->put().

get();
    $result = $conn->query('SELECT * FROM users');
    $pool->put($conn);
});

Step 5: Implement coroutines sharing the same connection pool

In actual application scenarios, it is usually necessary to implement the requirement for coroutines to share the same connection pool. At this time, we can achieve it through dependency injection.

 '127.0.0.1',
    'port' => 3306,
    'user' => 'root',
    'password' => '',
    'database' => 'test_db',
    'charset' => 'utf8mb4',
    'timeout' => 30,
    'strict_type' => true,
    'fetch_mode' => true,
    'max_idle_time' => 3,
    'max_object_num' => 20,
];

$pool = new SwooleCoroutineMySQLPool($dbconfig);

// 注册依赖库
$container = new Container();
$container->singleton(Pool::class, function () use ($pool) {
    return $pool;
});

Registered the connection pool instance to the container in the code, and used the singleton() method to set it as a singleton object to ensure that multiple coroutines share the same connection pool instance .

The following demonstrates how to use the connection pool in the coroutine:

make(Pool::class);
    $conn = $pool->get();
    $result = $conn->query('SELECT * FROM users');
    $pool->put($conn);
});

// 协程2
go(function () use ($container) {
    $pool = $container->make(Pool::class);
    $conn = $pool->get();
    $result = $conn->query('SELECT * FROM users');
    $pool->put($conn);
});

Through the make() method, you can obtain dependent library instances in the coroutine to achieve multiple coroutines. processes share the same database connection.

Summary

Swoole's coroutine sharing technology can avoid frequent database connections and improve application performance and scalability. When realizing that coroutines share the same connection pool, we can achieve it through dependency injection, so as to achieve the purpose of multiple coroutines sharing the same database connection. Next time you need to use Swoole's coroutine technology when developing an application, you might as well try coroutine sharing technology to improve the efficiency of the application.

The above is the detailed content of How do all Swoole coroutines share the same database connection?. For more information, please follow other related articles on the PHP Chinese website!