You initialize the locking subsystem by specifying DB_INIT_LOCK to the DB_ENV->open() method.

Before opening your environment, you can configure various maximum values for your locking subsystem. Note that these limits can only be configured before the environment is opened. Also, these methods configure the entire environment, not just a specific environment handle.

Finally, each bullet below identifies the DB_CONFIG file parameter that can be used to specify the specific locking limit. If used, these DB_CONFIG file parameters override any value that you might specify using the environment handle.

The limits that you can configure are as follows:

For a definition of lockers, locks, and locked objects, see Lock Resources.

For example, to configure the maximum number of locks that your environment can use:

#include <stdio.h>
#include <stdlib.h>

#include "db.h"

int
main(void)
{
    int ret, ret_c;
    u_int32_t env_flags;
    DB_ENV *envp;
    const char *db_home_dir = "/tmp/myEnvironment";
    
    envp = NULL;

    /* Open the environment */
    ret = db_env_create(&envp, 0);
    if (ret != 0) {
        fprintf(stderr, "Error creating environment handle: %s\n",
            db_strerror(ret));
        return (EXIT_FAILURE);
    }
                                                                                                                                  
    env_flags = DB_CREATE     |  /* If the environment does not
                                  * exist, create it. */
                DB_INIT_LOCK  |  /* Initialize locking */
                DB_INIT_LOG   |  /* Initialize logging */
                DB_INIT_MPOOL |  /* Initialize the cache */
                DB_THREAD     |  /* Free-thread the env handle. */
                DB_INIT_TXN;     /* Initialize transactions */
                                                                                                                                  
    /* Configure max locks */
    ret = envp->set_lk_max_locks(envp, 5000);
    if (ret != 0) {
        fprintf(stderr, "Error configuring locks: %s\n",
            db_strerror(ret));
        goto err;
    }

    /* Open the environment. */
    ret = envp->open(envp, db_home_dir, env_flags, 0);
    if (ret != 0) {
        fprintf(stderr, "Error opening environment: %s\n",
            db_strerror(ret));
        goto err;
    }

err:
    /* Close the environment */
    if (envp != NULL) {
        ret_c = envp->close(envp, 0);
        if (ret_c != 0) {
            fprintf(stderr, "environment close failed: %s\n",
                db_strerror(ret_c));
            ret = ret_c;
        }
    }

    return (ret == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
} 

In order for DB to know that a deadlock has occurred, some mechanism must be used to perform deadlock detection. There are three ways that deadlock detection can occur:

For example, to configure your application such that DB checks the lock table for deadlocks every time a lock request is blocked:

#include <stdio.h>
#include <stdlib.h>

#include "db.h"

int
main(void)
{
    int ret, ret_c;
    u_int32_t db_flags, env_flags;
    DB *dbp;
    DB_ENV *envp;
    DB_TXN *txn;
    const char *db_home_dir = "/tmp/myEnvironment";
    const char *file_name = "mydb.db";
    
    envp = NULL;

    /* Open the environment */
    ret = db_env_create(&envp, 0);
    if (ret != 0) {
        fprintf(stderr, "Error creating environment handle: %s\n",
            db_strerror(ret));
        return (EXIT_FAILURE);
    }
                                                                                                                                  
    env_flags = DB_CREATE     |  /* If the environment does not
                                  * exist, create it. */
                DB_INIT_LOCK  |  /* Initialize locking */
                DB_INIT_LOG   |  /* Initialize logging */
                DB_INIT_MPOOL |  /* Initialize the cache */
                DB_THREAD     |  /* Free-thread the env handle. */
                DB_INIT_TXN;     /* Initialize transactions */

    /*
     * Configure db to perform deadlock detection internally, and to
     * choose the transaction that has performed the least amount of writing
     * to break the deadlock in the event that one is detected.
     */
    ret = envp->set_lk_detect(envp, DB_LOCK_MINWRITE);
    if (ret != 0) {
        fprintf(stderr, "Error setting lk detect: %s\n",
            db_strerror(ret));
        goto err;
    }

    ret = envp->open(envp, db_home_dir, env_flags, 0);
    if (ret != 0) {
        fprintf(stderr, "Error opening environment: %s\n",
            db_strerror(ret));
        goto err;
    }

    /* 
     * From here, you open your databases, proceed with your 
     * database operations, and respond to deadlocks as 
     * is normal (omitted for brevity).
     */

     ...  

Finally, the following command line call causes deadlock detection to be run against the environment contained in /export/dbenv. The transaction with the youngest lock is chosen to break the deadlock:

> /usr/local/db_install/bin/db_deadlock -h /export/dbenv -a y

For more information, see the db_deadlock reference documentation.

When DB determines that a deadlock has occurred, it will select a thread of control to resolve the deadlock and then return DB_LOCK_DEADLOCK to that thread. If a deadlock is detected, the thread must:

For example:

retry:
    ret = envp->txn_begin(envp, NULL, &txn, 0);
    if (ret != 0) {
            envp->err(envp, ret, "txn_begin failed");
            return (EXIT_FAILURE);
    }
    ...
    /* key and data are Dbts. Their usage is omitted for brevity. */
    ...
    switch (ret = dbp->put(dbp, txn, &key, &data, 0)) {
        case 0:
            break;
        /* Deadlock handling goes here */
        case DB_LOCK_DEADLOCK:
            /* Abort the transaction */
            (void)txn->abort(txn);

            /* 
             * retry_count is a counter used to identify how many times
             * we've retried this operation. To avoid the potential for
             * endless looping, we won't retry more than 
             * MAX_DEADLOCK_RETRIES times.
             */
            if (retry_count < MAX_DEADLOCK_RETRIES) {
                printf("Got DB_LOCK_DEADLOCK.\n");
                printf("Retrying write operation.\n");
                    retry_count++;
                    goto retry;
             }
             printf("Got DB_LOCK_DEADLOCK and out of retries.");
             printf("Giving up.\n");
             return (EXIT_FAILURE);
         default:
            /* If some random database error occurs, we just give up */
            envp->err(envp, ret, "db put failed");
            ret = txn->abort(txn);
            if (ret != 0) {
                envp->err(envp, ret, "txn abort failed");
                return (EXIT_FAILURE);
             } 
         }
    /* If all goes well, commit the transaction */
    ret = txn->commit(txn, 0);
    if (ret != 0) {
        envp->err(envp, ret, "txn commit failed");
        return (EXIT_FAILURE);
    }

    return (EXIT_SUCCESS);