[asio-users] Locking Problem (App Level)

[U.Mutlu <for...@mu...>]

Hi,
in my current project I'm confronted with an IMO challenging
real-world problem, and am looking for an optimal or near-optimal
solution for it:

There is a standard vector (std::vector) of structs
(ie. data records), and 3 threads working on that vector:
  thread 1: about every 10 seconds appends a new record
            to the vector, or updates an existing record,
            there are no deletions done.
  thread 2: walks over all records in a read-only manner
            and generates a list; it takes about 60 seconds.
  thread 3: walks over all records in a read-only manner
            and generates a different list; it takes about 90 seconds.

Of course all threads are running simultanously, but thread 2 fires
its job every 3 minutes, thread 3 every 5 minutes, and thread 1 is
permanently working (reacting on external events).

The problem is this: when thread 2 or 3 are running (remember 60 or 90 seconds)
then using the usual shared locking schemes thread 1 cannot do its job,
although it is the most important thread and its job is
time-critical (recording external events).

Is there a better locking solution to this problem?

(I think I need something like "record locking" instead if locking
the whole vector, isn't it?
But then one of course cannot spend a mutex for every of the 50+k records, isn't it?
How to do it else?)