A queued function (void) for multiple threads in C#

Question

I have multiple threads in my C# program. Now they call a specific function once in a while during their runtime. Now I want to make sure that they never execute that specific function at the same time (since it leads to some anomalies in my program), one call to the function must finish before the next call starts. (much like a queue).

Is it possible to accomplish this? (Does not have to be a function).

Here's a diagram if some couldn't understand:

just wrap your function's calls into a `lock` statement (https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/lock-statement). Or just add a `lock` inside function itself. — Serg, Nov 21 '21 at 07:46
Thanks so much, It works! (You can write it as an answer so that I can mark it as the correct one). — cherryguy, Nov 21 '21 at 09:19
You might find this question interesting: [What does a lock statement do under the hood?](https://stackoverflow.com/questions/6029804/what-does-a-lock-statement-do-under-the-hood) — Theodor Zoulias, Nov 21 '21 at 11:55
It would be interesting to know more about your program as Microsoft's Reactive Framework might be a good solution here depending on your architecture. — Enigmativity, Nov 22 '21 at 02:26

score 2 · Accepted Answer · answered Nov 21 '21 at 10:55

You can use lock keyword to prevent execution of code fragment in parallel. Just wrap your function's calls into a lock statement or add a lock inside function itself.

class MyClass
{
    private object lockObj = new();
    
    public void MyFunction()
    {
        lock(lockObj)
        {
            //code goes here
        }
    }
}

    //usage
    void Test()
    {
        var myClass = new MyClass();
        var thread1 = new Thread(ThreadFunc);
        var thread2 = new Thread(ThreadFunc);
        
        thread1.Start(myClass);
        thread2.Start(myClass);
    }
    
    public static void ThreadFunc(object myClassObj)
    {
        var myClass = (MyClass)myClassObj;
        myClass.MyFunction();
    }

Note lockObj object here. To acheive behaviour you want, you should use exactly the same lockObj value in the lock statements. So, the following is WRONG

//WRONG, do NOT DO this
    var myClass1 = new MyClass();
    var myClass2 = new MyClass();
    var thread1 = new Thread(ThreadFunc);
    var thread2 = new Thread(ThreadFunc);

    thread1.Start(myClass1);
    thread2.Start(myClass2);

Here we have two independent instances of MyClass, so each instance has their own value of lockObj and thus this instances will not lock each other, so parallel exectution of myClass1.MyFunction() and myClass2.MyFunction() is allowed here.

A queued function (void) for multiple threads in C#

1 Answers1