EWL C++ Thread Safety Policy

EWL C++ is Level-1 thread safe. That is:

• It is safe to simultaneously call const and non-const methods from different threads to distinct objects.

• It is safe to simultaneously call const methods, and methods from different threads to the same object as long as such methods and const methods
  • Are guaranteed to not alter the state of an object
  • Do not invalidate outstanding references or iterators of a container
• It is not safe for different threads to simultaneously access the same object when at least one thread calls non-const methods, or methods that invalidate outstanding references or iterators to the object. The programmer is responsible for using thread synchronization primitives (e.g. mutex) to avoid such situations.

Simultaneous use of allocators such as new and malloc are thread safe.

Simultaneous use of global objects such as cin and cout is not safe. The programmer is responsible for using thread synchronization primitives to avoid such situations. EWL C++ provides an extension to standard C++ (std::mutex) to aid in such code. For example:

#include <iostream>
#include <iomanip>

#include <mutex.h>

std::mutex cout_lock;

int main()

{

   cout_lock.lock();

   std::cout << "The number is " << 

   std::setw(5) << 20 << '\n';

   cout_lock.unlock();

}

Note that if only one thread is accessing a standard stream then no synchronization is necessary. For example, one could have one thread handling input from cin, and another thread handling output to cout, without worrying about mutex objects.