Question

I’m wondering what is the “best” way to make data thread-safe.

Specifically, I need to protect a linked-list across multiple threads — one thread might try to read from it while another thread adds/removes data from it, or even frees the entire list. I’ve been reading about locks; they seem to be the most commonly used approach, but apparently they can be problematic (deadlocks). I’ve also read about atomic-operations as well as thread-local storage.

In your opinion, what would be my best course of action? What’s the approach that most programmers use, and for what reason?

Answer 1

One approach that is not heavily used, but quite sound, is to designate one special purpose thread to own every “shared” structure. That thread generally sits waiting on a (thread-safe;-) queue, e.g. in Python a Queue.Queue instance, for work requests (reading or changing the shared structure), including both ones that request a response (they’ll pass their own queue on which the response is placed when ready) and ones that don’t. This approach entirely serializes all access to the shared resource, remaps easily to a multi-process or distributed architecture (almost brainlessly, in Python, with multiprocessing;-), and absolutely guarantees soundness and lack of deadlocks as well as race conditions as long as the underlying queue object is well-programmed once and for all.

It basically turns the hell of shared data structures into the paradise of message-passing concurrency architectures.

OTOH, it may be a tad higher-overhead than slugging it out the hard way with locks &c;-).