The Berkeley DB library is not itself multi-threaded.
The library was deliberately architected to not use threads internally
because of the portability problems that using threads within the library
Object handles returned from Berkeley DB library functions are free-threaded,
i.e., threads may use handles concurrently, by specifying the DB_THREAD
flag to db_appinit and the other subsystem open functions.
Threading is assumed in the Java API, so no special flags are required,
and Berkeley DB functions will always behave as if the DB_THREAD flag was specified.
Berkeley DB supports multi-threaded applications with the caveat that it loads
and calls functions that are commonly available in C language environments
and which may not themselves be thread-safe.
Other than this usage,
Berkeley DB has no static data and maintains no local context between calls to
Berkeley DB functions.
To ensure that applications can safely use threads in the context of Berkeley DB,
porters to new operating systems and/or C libraries must confirm that the
system and C library functions used by the Berkeley DB library are thread-safe.
There are some additional caveats about using threads to access
the Berkeley DB library:
The DB_THREAD flag must be specified for all subsystems either explicitly
or via the db_appinit function. Threading is assumed in the Java
API, so no special flags are required, and Berkeley DB functions will always
behave as if the DB_THREAD flag was specified.
Setting the DB_THREAD flag inconsistently may result in database corruption.
Only a single thread may call the DB->close function for a
returned database or subsystem handle.
When using the non-cursor Berkeley DB calls to retrieve key/data items (e.g.,
DB->get), the memory referenced by the pointer stored into the Dbt
is only valid until the next call to using the DB handle
returned by db_open. (This includes any use of the returned
DB handle, including by another thread of control within the
process. For this reason, when multiple threads are using the returned
DB handle concurrently, either the DB_DBT_MALLOC or
DB_DBT_USERMEM flag must be specified for any non-cursor
DBT used for key or data retrieval.) When using the cursor Berkeley DB
calls to retrieve key/data items (e.g., dbc_get), the memory
referenced by the pointer into the DBT is only valid until the
next call to Berkeley DB using the DBC handle returned by
The DB_CURRENT, DB_NEXT and DB_PREV flags to the log_get function
may not be used by a free-threaded handle. If such calls are necessary,
a thread should explicitly create a unique DB_LOG handle by calling
Each database operation (i.e., any call to a function underlying the
handles returned by db_open and DB->cursor is normally
performed on behalf of a unique locker. If, within a single thread of
control, multiple calls on behalf of the same locker are desired, then
transactions must be used. For example, consider the case where a cursor
scan locates a record, and then based on that record, accesses some other
item in the database. If these are done using the default lockers for
the handle, there is no guarantee that these two operations will not
conflict. If the application wishes to guarantee that the operations do
not conflict, locks must be obtained on behalf of a transaction, instead
of the default locker id, and a transaction must be specified to the
cursor creation and the subsequent
Berkeley DB calls.
Transactions may not span threads, i.e., each transaction must begin and
end in the same thread, and each transaction may only be used by a single
Spinlocks must have been implemented for the compiler/architecture
combination. Attempting to specify the DB_THREAD flag will fail if
spinlocks are not available.
The Berkeley DB library makes a system call to pause for some number of
microseconds when it is necessary to wait on a lock. This may not be
optimal, especially in a thread-only environment where it will be more
efficient to explicitly yield the processor to another thread. It is
possible to specify a
on an per-application basis.
Compiling Threaded Applications
Special compile-time flags are required when compiling threaded applications
with the UNIX include files on some architectures.
On FreeBSD, if you are compiling a threaded application, you must
compile with the _THREAD_SAFE flag and link with the libc_r.a
cc -D_THREAD_SAFE ... -lc_r
On IRIX, if you are compiling a threaded application,
you must compile with the _SGI_MP_SOURCE flag:
cc -D_SGI_MP_SOURCE ...
On OSF/1, if you are compiling a threaded application,
you must compile with the _REENTRANT flag:
cc -D_REENTRANT ...
On Solaris, if you are compiling a threaded application, you must compile
with the _REENTRANT flag and link with the libthread.a library: