Menu
I'm looking for a good name to give to data structures that are thread safe / internally synchronized.
The C++ standard uses the term atomic, but atomic has some rather special meaning. Microsoft uses the term Concurrent in their Thread-Safe Collections (or in C++ _concurrent in the Parallel Containers).
What I really would like would be a generic wrapper for (value) types that provides a similar set of operations to what std::atomics do, but with a different name, and some typedefs derived from it. (use case: something like std::atomic for std::string)
Which of the following would you consider useful / not useful and why?
SynchronizedThingamajig (or thingamajig_synchronized or synchronized_thingamajig)Concurrent...ThreadSafe...Safe...Parallel...Locked...Mutex ... or Mutexed...
Multithreaded...For the string example I gave, maybe a synchronized_string or a concurrent_string would make most sense, or would that clash with any other connotation?
234
A thread-safe class is a class that guarantees the internal state of the class as well as returned values from methods, are correct while invoked concurrently from multiple threads. The collection classes that are thread-safe in Java are Stack, Vector, Properties, Hashtable, etc.
Thread Safe Code Lets look at the following code snippet : ... ... ... char arr[10]; int index=0; int func(char c) { int i=0; if(index >= sizeof(arr)) { printf("\n No storage\n"); return -1; } arr[index] = c; index++; return index; } ... ... ...
A method will be thread safe if it uses the synchronized keyword in its declaration. However, even if your setId and getId methods used synchronized keyword, your process of setting the id (if it has not been previously initialized) above is not. .. but even then there is an "it depends" aspect to the question.
Thread safety is the avoidance of data races—situations in which data are set to either correct or incorrect values, depending upon the order in which multiple threads access and modify the data.
Useful answer from comment:
Both Microsoft PPL and Intel TBB use
concurrent_*. My only suggestion is: Don't use parallel when you mean concurrent. (Parallel is one kind of concurrency, but these data structures should work even on a single processor time-multiplexing multiple threads.) You might also look at the monitor pattern.
-- Wandering Logic Jun 18 at 12:02
To which I might add that from the choices I gave, after thinking some more about it, only concurrent and synchronized seem to make sense.
66
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With
