I have a need to almost-constantly iterate over a sequence of structs in a read-only fashion but for every 1M+ reads, one of the threads may append an item. I think using a mutex would be overkill here and I also read somewhere that r/w locks have their own drawbacks for the readers.

I was thinking about using reserve() on a std::vector but this answer [Iterate over STL container using indices safe way to avoid using locks?](https://stackoverflow.com/questions/15370644/iterate-over-stl-container-using-indices-safe-way-to-avoid-using-locks) seemed to invalidate that.

Any ideas on what way might be fastest? The most important thing is for the readers to be able to quickly and efficiently iterate with as little contention as possible. The writing operations aren't time-sensitive.

Update: Another one of my use cases is that the "list" could contain pointers rather than structs. I.e, std::vector. Same requirements apply.

Update 2: Hypothetic example

globally accessible:

```
typedef std::vector<MyClass*> Vector;
Vector v;
v.reserve(50);

```

Reader threads 1-10: (these run pretty much run all the time)

```
.
.
int total = 0;
for (Vector::const_iterator it = v.begin(); it != v.end(); ++it)
{
   MyClass* ptr = *it;
   total += ptr->getTotal();
}
// do something with total
.
.

```

Writer threads 11-15:

```
MyClass* ptr = new MyClass();
v.push_back(ptr);

```

That's basically what happens here. threads 1-15 could all be running concurrently although generally there are only 1-2 reading threads and 1-2 writer threads.