/ /

Utiliza un pool de conexiones

Overview

En esta guía, puedes aprender a usar el driver de C++ para crear y configurar un pool de conexiones. Un pool de conexiones es una memoria caché de objetos cliente que tu aplicación puede usar para gestionar múltiples operaciones concurrentes de MongoDB.

Después de instanciar un mongocxx::pool, el pool crea objetos cliente según sea necesario hasta alcanzar el tamaño máximo del pool. Cada hilo que ejecuta operaciones de MongoDB saca un cliente del pool, lo utiliza para realizar operaciones y devuelve el cliente al pool. El conjunto gestiona automáticamente el ciclo de vida de estos clientes.

Importante

A diferencia de la mayoría de los drivers MongoDB, el driver C++ no implementa la especificación de Supervisión de Conexiones y Pooling (CMAP) de MongoDB. En este contexto, el agrupamiento de conexiones se refiere a la caché del driver de objetos cliente en lugar de conexiones de base de datos.

Comparación de pool de conexiones y clientes

Los pools de conexiones ofrecen ventajas de rendimiento significativas sobre los clientes autónomos. Un mongocxx::pool utiliza subprocesos de supervisión en segundo plano independientes para supervisar continuamente el clúster. Como resultado, los hilos de la aplicación pueden realizar operaciones sin esperar a que finalice la supervisión de la topología. Por el contrario, un mongocxx::client autónomo se detiene periódicamente para verificar el estado del clúster, bloqueando todas las operaciones durante la verificación.

Puede usar un pool de conexiones incluso si su aplicación utiliza solo un hilo. La supervisión en segundo plano del pool proporciona un rendimiento mejor que los controles periódicos de un cliente autónomo.

La siguiente tabla resume las principales diferencias entre mongocxx::pool y mongocxx::client:

funcionalidad	`mongocxx::pool`	`mongocxx::client`
Recomendado para aplicaciones multihilo	Sí.	No.
Supervisión en segundo plano	Sí. Los pools usan un hilo separado para cada servidor.	No. Los clientes realizan verificaciones periódicas de bloqueo.
Intervalo de supervisión	Cada 10 segundos por servidor.	Cada 60 segundos.
Seguridad de hilos	Seguro para subprocesos, pero los clientes adquiridos no son seguros para subprocesos.	No es seguro para subprocesos.
Seguridad en la bifurcación	Debes crear la pool después de hacer el fork.	Debe crear el cliente después de realizar el fork.

Tip

Hilo y bifurcación

Para aprender más sobre cómo utilizar clientes y objetos de cliente en varios hilos y cuando se bifurcan procesos, consulta la guía Seguridad en hilos y bifurcaciones.

Crear un pool de conexiones

Para crear un pool de conexiones, instancie un objeto mongocxx::pool pasando su URI de conexión a su constructor. Cada subproceso que ejecute operaciones de MongoDB debe adquirir un cliente del pool llamando a la función nodo acquire(). Cuando el cliente sale del alcance, retorna automáticamente al grupo.

Este archivo de muestra realiza las siguientes acciones:

Crea un pool de conexiones
Crea tres subprocesos que cada uno adquiere su propio cliente del grupo
Realiza una operación de inserción en cada hilo

1 #include <iostream>
2 #include <thread>
3 #include <vector>
4 
5 #include <bsoncxx/builder/basic/document.hpp>
6 #include <bsoncxx/builder/basic/kvp.hpp>
7 #include <mongocxx/instance.hpp>
8 #include <mongocxx/pool.hpp>
9 #include <mongocxx/uri.hpp>
10 
11 using bsoncxx::builder::basic::kvp;
12 using bsoncxx::builder::basic::make_document;
13 
14 int main() {
15     mongocxx::instance instance{};
16     
17     mongocxx::uri uri{"mongodb://localhost:27017"};
18     mongocxx::pool pool{uri};
19     
20     std::vector<std::thread> threads;
21     
22     // Creates multiple threads that each acquire a client from the pool
23     for (int i = 0; i < 3; ++i) {
24         threads.emplace_back([&pool, i]() {
25             auto client = pool.acquire();
26             auto collection = (*client)["db"]["coll"];
27             
28             // Inserts a sample document
29             collection.insert_one(make_document(kvp("thread_id", i)));
30             
31             std::cout << "Thread " << i << " inserted a document" << std::endl;
32         });
33     }
34     
35     // Waits for all threads to complete
36     for (auto& thread : threads) {
37         thread.join();
38     }
39     
40     std::cout << "All threads completed" << std::endl;
41     
42     return 0;
43 }

Configurar las Opciones de pool de conexiones

Puedes configurar el comportamiento del pool de conexiones incluyendo opciones en tu URI de conexión. La siguiente tabla describe las opciones de la pool de conexiones que puedes configurar:

Opción de URI	Descripción
`maxPoolSize`	Especifica el número máximo de clientes que el pool puede crear. Cuando se alcanza este límite, la función de nodo `acquire()` se bloquea hasta que otro hilo devuelve un cliente al pool. Por defecto, `100`. Tipo: `int`
`minPoolSize`	Especifica el número mínimo de clientes que el pool mantiene. El pool crea este número de clientes cuando se inicializa y mantiene al menos este número de clientes continuamente. Por defecto `0`. Tipo: `int`
`waitQueueTimeoutMS`	Especifica el tiempo máximo en milisegundos que la función `acquire()` espera a que un cliente esté disponible cuando el grupo haya alcanzado el valor `maxPoolSize`. Si este tiempo de espera expira, la función `acquire()` genera un error. Por defecto, no hay tiempo de espera. Tipo: `int`

Ejemplo

El siguiente ejemplo especifica la opción maxPoolSize para crear un pool de conexiones con un tamaño máximo de 5 clientes:

mongocxx::uri uri{"mongodb://localhost:27017/?maxPoolSize=5"};
mongocxx::pool pool{uri};

Documentación de la API

Para obtener más información sobre los tipos y las funciones tratados en esta guía, consulta la siguiente documentación de la API:

Volver

Stable API

Configuración e instalación avanzadas

1	#include <iostream>
2	#include <thread>
3	#include <vector>
4
5	#include <bsoncxx/builder/basic/document.hpp>
6	#include <bsoncxx/builder/basic/kvp.hpp>
7	#include <mongocxx/instance.hpp>
8	#include <mongocxx/pool.hpp>
9	#include <mongocxx/uri.hpp>
10
11	using bsoncxx::builder::basic::kvp;
12	using bsoncxx::builder::basic::make_document;
13
14	int main() {
15	mongocxx::instance instance{};
16
17	mongocxx::uri uri{"mongodb://localhost:27017"};
18	mongocxx::pool pool{uri};
19
20	std::vector<std::thread> threads;
21
22	// Creates multiple threads that each acquire a client from the pool
23	for (int i = 0; i < 3; ++i) {
24	threads.emplace_back([&pool, i]() {
25	auto client = pool.acquire();
26	auto collection = (*client)["db"]["coll"];
27
28	// Inserts a sample document
29	collection.insert_one(make_document(kvp("thread_id", i)));
30
31	std::cout << "Thread " << i << " inserted a document" << std::endl;
32	});
33	}
34
35	// Waits for all threads to complete
36	for (auto& thread : threads) {
37	thread.join();
38	}
39
40	std::cout << "All threads completed" << std::endl;
41
42	return 0;
43	}