Semaphore Mutex Concurrency Issue in multithreaded C program

Question

How do i design a multithreaded C program to avoid Semaphore Mutex Concurrency

Answer 1

There are a few ways.

The best way is to eliminate all shared data between threads. While this isn't always practical, it's always good to eliminate as much shared data as possible.

After that, you need to start looking into lockless programming. Lockless programming is a bit of a fad right now, but the dirty secret is that it's often a much better idea to use lock-based concurrency like mutexes and semaphores. Lockless programming is very hard to get correct. Look up Herb Sutter's articles on the subject, or the wikipedia page. There are a lot of good resources about lockless synchronization out there.

Somewhere in between is critical sections. If you're programming on Windows, critical sections should be preferred to mutexes as they do some work to avoid the overhead of full mutex locks and unlocks. Try those out first, and if your performance is unacceptable (or you're targeting platforms without critical sections), then you can look into lockless techniques.

Answer 2

It would be best to program lock less code. It's hard, but possible.

GCC Atomic Builtins

Article by Andrei Alexandrescu (C++)

Answer 3

Be sure to pass on data structures between threads, always knowing which thread the data exclusively belongs to. If you use (as mentioned by Dan before) e.q. lockless queues to pass your data around, you shouldn't run into too many concurrency issues (as your code behaves much more like any other code waiting for some data to arrive).

If you are, however, migrating single- to multithreaded code - this is an entirely different beast. It's very hard. And most of the time there are no elegant solutions.

Answer 4

Also, have a look at InterlockedXXX series to perform atomic operation in multi-threaded environment.

• InterlockedIncrement Function
• InterlockedDecrement Function
• InterlockedExchange Function