Series of if's in loop not working properly

Question

0.00/5 (No votes)

See more:

I am oversimplifying for the sake of clarity. Hoping someone has come across this kind of weird behavior.

I have two threads that each contain loops going very fast, Thread1 one updates a series of a variables, and Thread2 has a series of ifs designed to act on those variable values. Thread2:

C#

if (A & B)
{
    Flag1 = true;
}

if ((Flag1==true) && foobar1)
{
    Flag1 = false;
    // Do something;
}

The really weird behavior is that Flag1 is definitely not behaving correctly. It gets set to true when the variables in the Thread1 do not warrant that. What's more, using timers it seems that there is a kind of time lag. For example, the calculated elapsed time (using timer) is much smaller than the elapsed time indicated by the debugger. I think this might have something to do with it (in addition to my lack of knowledge). Help!

What I have tried:

I have tried tracking various variables in Thread1 to verify the erroneous behavior.

Posted 24-Jun-22 4:43am

Admin BTA

Updated 24-Jun-22 5:33am

Graeme_Grant

v3

Add a Solution

Comments

Graeme_Grant 24-Jun-22 10:52am

I'm not sure what you are doing or why but I don't like the design.

The issue that you have is that you're not doing threadsafe operations.

2 solutions

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

DaveAuld · Accepted Answer · 2022-06-24T05:18:00

Solution 1

I think you need to be moving your shared flags into a thread safe operation using the likes of Interlocked.

See this docs on the Interlock Class
Interlocked Class (System.Threading) | Microsoft Docs[^]

Posted 24-Jun-22 5:18am

DaveAuld

Comments

Graeme_Grant 24-Jun-22 11:25am

It's a bit more involved than just interlocking variables.

OriginalGriff · Accepted Answer · 2022-06-24T05:33:00

Threading isn't a "magic bullet": it's complicated, particularly when you try to get two threads operating on the same data.

Think about it for a moment: each thread runs on a separate core, each with it's own processor and (at least) L1 instruction and data caches. And by design, they don't know about each other. Combine that with register optimization in the JIT compiled code, and it's unlikely that they share any "real" data at all!

To make life even more fun, a simple instruction in C# like

C#

i++;

is not atomic in machine code: it may be a fetch of i as one machine instruction, an increment as a second, and a store as a third. And since cores are independant, even if a value is genuinely stored in no cached memory there is no guarantee that the change will be done correctly because two cores could be reading it at the same time, changing it at the same time, or storing it at the same time - and the last one to execute wins the result!

So when you have a tight loop operating with minimal data, the chances are that it's all working in registers or cache inside the running core, and any changes one thread makes to a variable aren't reflected back to the actual memory until the thread is p paused by OS to free up the core for other threads in the system.

When this happens, your data is called "not thread safe" and very odd, unpredictable, and even intermittent effects can be seen.

To make it thread safe, you have to "lock" the data so other threads can't access it, do what you need with it, then unlock it again each time you want to do anything. And that means the other threads are paused waiting for you to release the lock, because they have to do exactly the same thing each time!
And that raises it's own problems if you aren't careful: deadlocks, where each thread is paused waiting for a lock the other has taken for example; ora massive slowdown in processing speed because locking adds it's own overhead and if threads are constantly waiting for other thread to finish with something, it can get slower than a single-threaded app!

And your design? That's not thread safe, not even close. And making it thread safe is going to take a lot of sitting down and thinking ... once you have finished researching thread safety which is going to take a while as well!