searching concurrent linked list - c++

Question

I have a concurrent linked list. I need to prioritize finds on this list, so if a thread begins iterating over the list and subsequent insert/delete requests show up I'd want to queue those but if there are find requests from other threads I'd let those happen. What's the best way to implement this situation?
EDIT: I don't want to make copies of the list. Too expensive. Mom pays for my hardware.

Answer 1

Sounds like you are looking for a readers-/writer-lock. This is a lock that can be used to let many threads read the data-structure, but when one thread has write-access, all others are locked out.
Boost offers an implementation.

Answer 2

Are you on Windows ?
If so, you can use synchronization objects like Events or Mutexes.
For insert and delete, you can lock the mutex at the begining of those functions and release the mutex at the end of the function.
Steps shall be like below.
Create event object. http://msdn.microsoft.com/en-us/library/ms682655(VS.85).aspx
Lock the Event obect using WaitForSingleObject function at the start of insert/delete function.
http://msdn.microsoft.com/en-us/library/ms687032(VS.85).aspx
Use SetEvent to unlock the event object at the end of insert/delete function, so that the thread waiting on this event object will get the turn to do insertion/deletion.
http://msdn.microsoft.com/en-us/library/ms686211(VS.85).aspx
Reads do not need to acquire the lock. So no need of Event or Mutex for reading. Multiple threads can read concurrently from a shared buffer.
You can find general info on Reader-writer lock at
http://en.wikipedia.org/wiki/Readers-writer_lock
You can get example program at
http://msdn.microsoft.com/en-us/library/ms686915(v=VS.85).aspx

Answer 3

Sounds like a vanilla reader-writer lock is not quite what you want. As soon as you try to acquire the writer side of the lock, further readers will block until the writer completes, whereas you said you wanted additional threads doing reads to gain access even if there are inserts pending.
I'm not sure if what you want is safe. If there are enough reads going on, your insert/deletes could block forever.
If you really want this you can easily build it yourself, just as you can easily build a reader/writer lock on top of a standard mutex.
Note that this code is probably broken but maybe it gives you a general idea.
class UnfairReaderWriterMutex {
Mutex mutex;
CondVar condition;
int readers; // if positive, reader count; if -1, writer lock is held
public:
UnfairReaderWriterMutex() : counter(0) { }
void ReaderLock() {
mutex.Lock();
while (counter < 0) {
condition.Wait();
}
++readers;
mutex.Unlock();
}
void ReaderUnlock() {
mutex.Lock();
assert(readers > 0);
--readers;
condition.Notify(); // only need to wake up one writer
mutex.Unlock();
}
void WriterLock() {
mutex.Lock();
while (counter > 0) {
condition.Wait();
}
readers = -1;
mutex.Unlock();
}
void WriterUnlock() {
mutex.Lock();
assert(readers == -1);
readers = 0;
condition.NotifyAll(); // there may be multiple readers waiting
mutex.Unlock();
}
};
A typical reader/writer lock works just like this except that there's a flag stopping readers from acquiring the lock while there is a writer waiting.