Question

I am looking for the optimal strategy to use STL containers (like std::map and std::vector) and pthreads.

What is the canonical way to go? A simple example:

std::map<string, vector<string>> myMap;

How do we guarantee concurrency?

mutex_lock;
write at myMap;
mutex_unlock;

Additionally, I would like to know if pthreads and STL face performance issues when used together.

System: Liunx, g++, pthreads, no boost, no Intel TBB

Answer 1

The C++03 Standard does not talk about concurrency at all, So the concurrency aspect is left out as an implementation detail for compilers. So the documentation that comes with your compiler is where one should look to for answers related to concurrency.

Most of the STL implementations are not thread safe as such.

Since STL containers do not provide any explicit Thread safety, So yes you will have to use your own synchronization mechanism. And while you are at it You should use RAII rather than manage the synchronization resource(mutex unlock etc) manually.

You can refer the Documentations here:

MSDN:

If a single object is being written to by one thread, then all reads and writes to that object on the same or other threads must be protected. For example, given an object A, if thread 1 is writing to A, then thread 2 must be prevented from reading from or writing to A.

GCC Documentation says:
We currently use the SGI STL definition of thread safety, which states:

The SGI implementation of STL is thread-safe only in the sense that simultaneous accesses to distinct containers are safe, and simultaneous read accesses to to shared containers are safe. If multiple threads access a single container, and at least one thread may potentially write, then the user is responsible for ensuring mutual exclusion between the threads during the container accesses.

Point to Note: GCC’s Standard Library is a derivative of SGI’s STL code.