Can I make a thread-safe std::atomic<vector<int>>?
C++11 §29.5/1 says
There is a generic class template atomic. The type of the template argument T shall be trivially copyable (3.9).
What does trivially copyable mean?
§3.9 tells
Scalar types, trivially copyable class types (Clause 9), arrays of such types, and cv-qualified versions of these types (3.9.3) are collectively called trivially copyable types.
For class types (of which std::vector is):
A trivially copyable class is a class that:
- has no non-trivial copy constructors
- has no non-trivial move constructors
- has no non-trivial copy assignment operators
- has no non-trivial move assignment operators
- has a trivial destructor
According to this list std::vector is not trivially copyable and so you cannot use std::atomic<std::vector<int>>.
Since you know the size in advance and since you do not need to use methods that would require the vector be reallocated in a different location (like push_back). You can use std::vector<int>::resize or the size constructor to preallocate and preconstruct the required ints. Therefore your concurrent threads do not need to operate on the vector itself but on the elements.
If there is no access from different threads to the same element there is no race condition.
The same goes for int k[1000] which is trivially copyable. But you do not need it to be since the threads do not change the array/vector/list itself but the elements.
You don't need to. It is totally okay to access a std::vector from multiple threads, if
- you read objects
- you write to different objects
So just make sure, you create a vector of size n=1000 and depending on your thread number (1 to 4) you assign elements 0-249, 250-499 etc. to your threads.
So each of your thread computes n/nthreads elements.
Atomic can be instantiated with trivially copyable types. Vector is not such a type.