/ /

Usar um pool de conexões

Visão geral

Neste guia, você pode aprender como usar o driver C++ para criar e configurar um pool de conexões. Um pool de conexões é um cache de objetos de cliente que seu aplicativo pode usar para gerenciar várias operações simultâneas do MongoDB .

Após instanciar um mongocxx::pool, o pool cria objetos de cliente conforme necessário até atingir o tamanho máximo do pool. Cada thread que executa operações do MongoDB faz check-out de um cliente do pool, usa-o para executar operações e retorna o cliente ao pool. O pool gerencia automaticamente o ciclo de vida desses clientes.

Importante

Ao contrário da maioria dos drivers MongoDB, o driver C++ não implementa a especificação MongoDB Connection Monitoramento and Pooling (CMAP). Nesse contexto, o pool de conexões refere-se ao cache do driver de objetos de cliente em vez de conexões de banco de dados .

Comparação de pool de conexões e clientes

Os pools de conexões oferecem vantagens significativas de desempenho em relação aos clientes autônomo . Um mongocxx::pool usa threads de monitoramento em segundo plano separados para monitorar continuamente o cluster. Como resultado, os threads de aplicativo podem executar operações sem esperar que o monitoramento da topologia seja concluído. Por outro lado, um mongocxx::client autônomo para periodicamente para verificar o status do cluster, bloqueando todas as operações durante a verificação.

Você pode usar um pool de conexões mesmo que seu aplicativo use apenas um thread. O monitoramento em segundo plano do pool fornece melhor desempenho do que as verificações periódicas de um cliente autônomo .

A tabela a seguir resume as principais diferenças entre mongocxx::pool e mongocxx::client:

funcionalidade	`mongocxx::pool`	`mongocxx::client`
Recomendado para aplicativos multithread	Sim.	No.
Monitoramento em segundo plano	Sim. Os pools usam um thread separado para cada servidor.	Não. Os clientes realizam verificações periódicas de bloqueio.
Intervalo de monitoramento	A cada 10 segundos por servidor.	A cada 60 segundos.
Segurança de thread	Clientes seguros para threads, mas adquiridos não são seguros para threads.	Não é seguro para threads.
Segurança em fork	Você deve criar o pool após a bifurcação.	Você deve criar o cliente após a bifurcação.

Dica

Threading e Forking

Para saber mais sobre como usar clientes e objetos de cliente em vários threads e ao bifurcar processos, consulte o guia Segurança de threads e bifurcações.

Criar um pool de conexões

Para criar um pool de conexões, instancie um objeto mongocxx::pool passando seu URI de conexão para o construtor dele. Cada thread que executa operações MongoDB deve adquirir um cliente do pool chamando a função de nó acquire(). Quando o cliente sai do escopo, ele retorna automaticamente ao pool.

Este arquivo de amostra executa as seguintes ações:

Cria um pool de conexões
Cria três threads que cada um adquire seu próprio cliente a partir do pool
Executa uma operação de inserção em cada thread

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 opções do pool de conexões

Você pode configurar o comportamento do pool de conexões incluindo opções em seu URI de conexão. A tabela a seguir descreve as opções de pool de conexões que você pode definir:

Opção de URI	Descrição
`maxPoolSize`	Especifica o número máximo de clientes que o pool pode criar. Quando esse limite é atingido, a função de nó `acquire()` bloqueia até que outra thread retorne um cliente para o pool. O padrão é `100`. Tipo: `int`
`minPoolSize`	Especifica o número mínimo de clientes que o pool mantém. O pool cria esse número de clientes quando inicializado e mantém pelo menos esse número de clientes continuamente. O padrão é `0`. Tipo: `int`
`waitQueueTimeoutMS`	Especifica o tempo máximo em milissegundos que a função `acquire()` aguarda para que um cliente se torne disponível quando o pool atingir o valor `maxPoolSize`. Se esse tempo limite expirar, a função `acquire()` gerará um erro. O padrão é nenhum tempo limite. Tipo: `int`

Exemplo

O exemplo a seguir especifica a opção maxPoolSize para criar um pool de conexões com um tamanho máximo de 5 clientes:

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

Documentação da API

Para aprender mais sobre os tipos e funções discutidos neste guia, consulte a seguinte documentação da API:

Voltar

Stable API

Configuração e instalação avançadas

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	}