Using a mutex to block execution from outside the critical section

I'm not sure I got the terminology right but here goes - I have this function that is used by multiple threads to write data (using pseudo code in comments to illustrate what I want) //these are initiated in the constructor int* data; std::atomic<size_t> size; void write(int value) { //wait here while "read_lock" //set "write_lock" to "write_lock" + 1 auto slot = size.fetch_add(1, std::memory_order_acquire); data[slot] = value; //set "write_lock" to "write_lock" - 1 } the order of the writes is not important, all I need here is for each write to go to a unique slot Every once in a while though, I need one thread to read the data using this function int* read() { //set "read_lock" to true //wait here while "write_lock" int* ret = data; data = new int[capacity]; size = 0; //set "read_lock" to false return ret; } so it basically swaps out the buffer and returns the old one (I've removed capacity logic to make the snippets shorter) In theory this should lead to 2 operating scenarios: 1 - just a bunch of threads writing into the container 2 - when some thread executes the read function, all new writers will have to wait, the reader will wait until all existing writes are finished, it will then do the read logic and scenario 1 can continue. The question part is that I don't know what kind of a barrier to use for the locks - A spinlock would be wasteful since there are many containers like this and they all need cpu cycles I don't know how to apply std::mutex since I only want the write function to be in a critical section if the read function is triggered. Wrapping the whole write function in a mutex would cause unnecessary slowdown for operating scenario 1. So what would be the optimal solution here?