U.Mutlu wrote:
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?
It depends. How long does it take to make a copy of the vector? // thread 1 lock mutex; update vector; unlock mutex; // thread 2 lock mutex; make a copy of the vector; unlock mutex; walk over copy; // thread 3: see thread 2