/ /

Especificar opções de conexão

Página inicial do Docs

Bibliotecas do cliente

C++

Especificar opções de conexão

Página inicial do Docs

Bibliotecas do cliente

C++

Especificar opções de conexão

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 aplicação 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 do MongoDB , o driver C++ não implementa a especificação MongoDB Connection Monitoring 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 aplicação 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 aplicação 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 thread e bifurcação.

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 membro 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`	Specifies the maximum number of clients the pool can create. When this limit is reached, the `acquire()` member function blocks until another thread returns a client to the pool. Defaults to `100`. Type: `int`
`minPoolSize`	Specifies the minimum number of clients the pool maintains. The pool creates this number of clients when initialized and maintains at least this number of clients continuously. Defaults to `0`. Type: `int`
`waitQueueTimeoutMS`	Specifies the maximum time in milliseconds that the `acquire()` function waits for a client to become available when the pool has reached the `maxPoolSize` value. If this timeout expires, the `acquire()` function generates an error. Defaults to no timeout. Type: `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 saber 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	}