How to implement an atomic counter

by

Simply use:

std::atomic<int> id{};

int create_id() {
    return id++;
}

See http://en.cppreference.com/w/cpp/atomic/atomic/operator_arith

Related Contents:

  1. c++, std::atomic, what is std::memory_order and how to use them?
  2. What exactly is std::atomic?
  3. Can num++ be atomic for ‘int num’?
  4. When to use volatile with multi threading?
  5. When do I really need to use atomic instead of bool? [duplicate]
  6. Understanding std::atomic::compare_exchange_weak() in C++11
  7. Where is the lock for a std::atomic?
  8. Must I call atomic load/store explicitly?
  9. What does the [[carries_dependency]] attribute mean?
  10. How to implement multithread safe singleton in C++11 without using
  11. difference between standard’s atomic bool and atomic flag
  12. Why don’t compilers merge redundant std::atomic writes?
  13. Are C/C++ fundamental types atomic?
  14. Does std::atomic work appropriately?
  15. Are atomic variables lock-free?
  16. How to atomically negate an std::atomic_bool?
  17. Double-Checked Lock Singleton in C++11
  18. Is incrementing an int effectively atomic in specific cases?
  19. Acquire/Release versus Sequentially Consistent memory order
  20. Do I have to use atomic for “exit” bool variable?
  21. Start thread with member function
  22. Thread pooling in C++11
  23. What happens to a detached thread when main() exits?
  24. How do I terminate a thread in C++11?
  25. Example for boost shared_mutex (multiple reads/one write)?
  26. Does the C++ volatile keyword introduce a memory fence?
  27. When to use recursive mutex?
  28. Pass multiple arguments into std::thread
  29. How can I distinguish between high- and low-performance cores/threads in C++?
  30. How do “acquire” and “consume” memory orders differ, and when is “consume” preferable?
  31. What happens when an exception goes unhandled in a multithreaded C++11 program?
  32. Multithreading and multicore differences
  33. What operations are atomic in C#?
  34. Waiting for multiple futures?
  35. What’s the best way to lock multiple std::mutex’es?
  36. Can I use std::async without waiting for the future limitation?
  37. What are the “things to know” when diving into multi-threaded programming in C++
  38. How to easily make std::cout thread-safe?
  39. Using stdlib’s rand() from multiple threads
  40. Is it safe to read an integer variable that’s being concurrently modified without locking?
  41. Is it ok to read a shared boolean flag without locking it when another thread may set it (at most once)?
  42. What is lock-free multithreaded programming?
  43. What does the C++ compiler do to ensure that different but adjacent memory locations are safe to be used on different threads?
  44. What is the best way to wait on multiple condition variables in C++11?
  45. Use std::lock_guard with try_lock
  46. atomic increment and return counter
  47. Is std::lock() ill-defined, unimplementable, or useless?
  48. How to give priority to privileged thread in mutex locking?
  49. What is the difference between std::condition_variable::wait_for and std::condition_variable::wait_until?
  50. Difference between pointer and reference as thread parameter

Leave a Comment