I’ve heard i++ isn’t thread safe, is ++i thread-safe?

by

You’ve heard wrong. It may well be that "i++" is thread-safe for a specific compiler and specific processor architecture but it’s not mandated in the standards at all. In fact, since multi-threading isn’t part of the ISO C or C++ standards (a), you can’t consider anything to be thread-safe based on what you think it will compile down to.

It’s quite feasible that ++i could compile to an arbitrary sequence such as:

load r0,[i]  ; load memory into reg 0
incr r0      ; increment reg 0
stor [i],r0  ; store reg 0 back to memory

which would not be thread-safe on my (imaginary) CPU that has no memory-increment instructions. Or it may be smart and compile it into:

lock         ; disable task switching (interrupts)
load r0,[i]  ; load memory into reg 0
incr r0      ; increment reg 0
stor [i],r0  ; store reg 0 back to memory
unlock       ; enable task switching (interrupts)

where lock disables and unlock enables interrupts. But, even then, this may not be thread-safe in an architecture that has more than one of these CPUs sharing memory (the lock may only disable interrupts for one CPU).

The language itself (or libraries for it, if it’s not built into the language) will provide thread-safe constructs and you should use those rather than depend on your understanding (or possibly misunderstanding) of what machine code will be generated.

Things like Java synchronized and pthread_mutex_lock() (available to C/C++ under some operating systems) are what you need to look into (a).

(a) This question was asked before the C11 and C++11 standards were completed. Those iterations have now introduced threading support into the language specifications, including atomic data types (though they, and threads in general, are optional, at least in C).

More Related Contents:

  1. Should a class be thread-safe? [closed]
  2. Start thread with member function
  3. C++0x has no semaphores? How to synchronize threads?
  4. Thread pooling in C++11
  5. Mutex example / tutorial? [closed]
  6. What does the thread_local mean in C++11?
  7. How to check if a std::thread is still running?
  8. What exactly is std::atomic?
  9. std::lock_guard or std::scoped_lock?
  10. How would you implement your own reader/writer lock in C++11?
  11. C++ Equivalent to Java’s BlockingQueue
  12. Multithreaded Rendering on OpenGL
  13. std::unique_lock or std::lock_guard?
  14. How to set the stacksize with C++11 std::thread
  15. How to make a multiple-read/single-write lock from more basic synchronization primitives?
  16. unordered_map thread safety
  17. How do you use CreateThread for functions which are class members?
  18. How do I create a Window in different QT threads?
  19. clock function in C++ with threads
  20. How do I generate thread-safe uniform random numbers?
  21. What is the proper way of doing event handling in C++?
  22. qt thread with movetothread
  23. Waiting for multiple futures?
  24. std::map thread-safety
  25. Making a C++ class a Monitor (in the concurrent sense)
  26. C++11 std::mutex in Visual Studio 2012 deadlock when locked from DllMain()
  27. Using condition variable in a producer-consumer situation
  28. GCC std::thread not found in namespace std
  29. Threadsafe Vector class for C++
  30. Why does this simple std::thread example not work?

Leave a Comment