Question

I will try to make this question as generic as possible, but I will give a brief introduction to my actual problem –

I am trying to implement a concurrent skiplist for a priority queue. Each ‘node’, has a value, and an array of ‘forward’ nodes, where node.forward[i] represents the next node on the i-th level of the skiplist. For write access (i.e. insertions and deletions), I use a Spinlock (still to determine if that is the best lock to use)

My question is essentially, when I need a read access for a traversal,

node = node.forward[i]

What kind of thread safety do I need around something like this? If another thread is modifying node.forward[i] at exactly the same time that I read (with no current locking mechanism for read), what can happen here?

My initial thought is to have a ReaderWriterLockSLim on the getter and setter of the indexer for Forward. Will there be too much unnecessary locking in this scenario?

Edit: Or would it be best to instead use a Interlocked.Exchange for all of my reads?

Answer 1

If another thread is modifying node.forward[i] at exactly the same time that I read (with no current locking mechanism for read), what can happen here?

It really depends on the implementation. It’s possible to use Interlocked.Exchange when setting “forward” in a way that can prevent the references from being invalid (as it can make the “set” atomic), but there is no guarantee of which reference you’d get on read. However, with a naive implementation, anything can happen, including getting bad data.

My initial thought is to have a ReaderWriterLockSLim on the getter and setter of the indexer for Forward.

This is likely to be a good place to start. It will be fairly easy to make a properly synchronized collection using a ReaderWriterLockSlim, and functional is always the first priority.

This would likely be a good starting point.

Will there be too much unnecessary locking in this scenario?

There’s no way to know without seeing how you implement it, and more importantly, how it’s goign to be used. Depending on your usage, you can profile and look for optimization opportunities if necessary at that point.

On a side note – you might want to reconsider using node.Forward[i] as opposed to more of a “linked list” approach here. Any access to Forward[i] is likely to require a fair bit of synchronization to iterate through the skip list i steps, all of which will need some synchronization to prevent errors if there are concurrent writes anywhere between node and i elements beyond node. If you only look ahead one step, you can (potentially) reduce the amount of synchronization required.