# mongoc_client_pool_t

A connection pool for multi-threaded programs. See Connection Pooling.

## Synopsis

    typedef struct _mongoc_client_pool_t mongoc_client_pool_t

`mongoc_client_pool_t` is the basis for multi-threading in the MongoDB C driver. Since mongoc_client_t structures are not thread-safe, this structure is used to retrieve a new mongoc_client_t for a given thread. This structure is thread-safe, except for its destructor method, mongoc_client_pool_destroy(), which is not thread-safe and must only be called from one thread.

## Example

example-pool.c

    /* gcc example-pool.c -o example-pool $(pkg-config --cflags --libs
     * libmongoc-1.0) */

    /* ./example-pool [CONNECTION_STRING] */

    #include <mongoc/mongoc.h>
    #include <pthread.h>
    #include <stdio.h>

    static pthread_mutex_t mutex;
    static bool in_shutdown = false;

    static void *
    worker (void *data)
    {
       mongoc_client_pool_t *pool = data;
       mongoc_client_t *client;
       bson_t ping = BSON_INITIALIZER;
       bson_error_t error;
       bool r;

       BSON_APPEND_INT32 (&ping, "ping", 1);

       while (true) {
          client = mongoc_client_pool_pop (pool);
          /* Do something with client. If you are writing an HTTP server, you
           * probably only want to hold onto the client for the portion of the
           * request performing database queries.
           */
          r = mongoc_client_command_simple (
             client, "admin", &ping, NULL, NULL, &error);

          if (!r) {
             fprintf (stderr, "%s\n", error.message);
          }

          mongoc_client_pool_push (pool, client);

          pthread_mutex_lock (&mutex);
          if (in_shutdown || !r) {
             pthread_mutex_unlock (&mutex);
             break;
          }

          pthread_mutex_unlock (&mutex);
       }

       bson_destroy (&ping);
       return NULL;
    }

    int
    main (int argc, char *argv[])
    {
       const char *uri_string = "mongodb://127.0.0.1/?appname=pool-example";
       mongoc_uri_t *uri;
       bson_error_t error;
       mongoc_client_pool_t *pool;
       pthread_t threads[10];
       unsigned i;
       void *ret;

       pthread_mutex_init (&mutex, NULL);
       mongoc_init ();

       if (argc > 1) {
          uri_string = argv[1];
       }

       uri = mongoc_uri_new_with_error (uri_string, &error);
       if (!uri) {
          fprintf (stderr,
                   "failed to parse URI: %s\n"
                   "error message:       %s\n",
                   uri_string,
                   error.message);
          return EXIT_FAILURE;
       }

       pool = mongoc_client_pool_new (uri);
       mongoc_client_pool_set_error_api (pool, 2);

       for (i = 0; i < 10; i++) {
          pthread_create (&threads[i], NULL, worker, pool);
       }

       sleep (10);
       pthread_mutex_lock (&mutex);
       in_shutdown = true;
       pthread_mutex_unlock (&mutex);

       for (i = 0; i < 10; i++) {
          pthread_join (threads[i], &ret);
       }

       mongoc_client_pool_destroy (pool);
       mongoc_uri_destroy (uri);

       mongoc_cleanup ();

       return EXIT_SUCCESS;
    }

## Functions

- mongoc_client_pool_destroy()
- mongoc_client_pool_enable_auto_encryption()
- mongoc_client_pool_max_size()
- mongoc_client_pool_min_size()
- mongoc_client_pool_new()
- mongoc_client_pool_pop()
- mongoc_client_pool_push()
- mongoc_client_pool_set_apm_callbacks()
- mongoc_client_pool_set_appname()
- mongoc_client_pool_set_error_api()
- mongoc_client_pool_set_ssl_opts()
- mongoc_client_pool_try_pop()