Programming

Thanks.

Hi!

using pthreads synchronisation object (like mutex, read-write locks...) does more than just a simple "atomic access". It actually ensures proper memory visibility using appropriate memory barriers. Refer for instance to this article.

Cheers,
Loïc

If I have many shared variables (more than 100), what is the better solution?

Without knowing the problem you are trying to solve, my reply might be off the track.

BUT reading "I have more than 100 variables to synchronize between threads" rings to me bells like "subtle, sporadic bugs, headache debugging and unmaintainable code"... Try to refactor your code to get as less shared variables as possible.

Loïc

The real problem like this,
My program has about 10-15 threads, they do not run at the same time, depending on what service is triggered, and then each thread may maintain 5-6 shared variables; that means, if the thread is enabled then other threads may read/write these variables.
However, each shared variables many be an array or an array of structure, like

struct STRCTU_SAMPLE __variable_name__[ 100 ];

My solution now is to use a critical section, when a thread is read/write these variables, other thread should be wait, until the processing cycle is finished because each thread may read a shared variable from others thread (not just one) and also write result back to other shared variables.

At such case, is critical section better than mutux?

The structure of each thread like this:

---------- Post updated at 03:45 PM ---------- Previous update was at 03:30 PM ----------

My current solution like this:

Enter critical section
Leave critical section

Any better solution or structure about such system? Thanks.

What's controlling the critical section, if not a mutex?

You could try implementing a reader-writer lock if threads do a lot more reading than writing, otherwise, a mutex is about as good.

Good evening,

my answer might sound a bit harsh, but you still don't describe what is the original problem you want to solve. Rather you're describing which technical solution you came with to sort your problem out, which involves 15 threads and 5-6 shared variables per threads, where a variable might be an array of 100 or more elements. And this particular solution leads to a further problem, namely how to sanely synchronize this mess.

Of course, we could give you idea how to tackle the synchronization problem generated by your technical solution. But we might be even more efficient in providing guidance to the initial problem you're trying to solve. For instance, do you want to serve several requests coming e.g. from different TCP clients concurrently? Or you need to perform different processing on a piece of data in a pipeline fashion? ...

Do you understand my point?

Cheers,
Loïc