如何正确锁定Task.Run（）块

Question

I am writing an application where I use several methods that access to some shared resources, so implemented some safety via lock(thisLock){ [...] ]

All was well until I had to use a resources inside an async task. This is the code:

private object thisLock = new object();
[...]
private void UpdateStuff()
{
lock(thisLock)
   {
     Task.Run(()=>{[code where I use shared resources]});
   }
}

It seems to work fine, but I was wondering if this is the correct way to do, or if I should put the lock() part inside the Run(), like this:

private void UpdateStuff()
{

     Task.Run( () => {
        lock(thisLock)
        {
         [code where I use shared resources]
        }
     });    
}

I tried to get some information, but everything I found mentions the case when the keyword async is used, and this doesn't seems the case.

So, my question is: which one is the best/correct way to use a lock() with Task.Run()? Why?

Thank you!

EDIT: In order to clarify, my doubt is about when and how much the lock is effective, so basically I am asking if in the first case there is a possibility where the lock is valid just for the Run() call, since the content of the call itself could live in another thread, while in the second case the lock will be associated to the content and so be effective.

Answer 1

Your first approach is entirely wrong. Task.Run can either execute the work synchronously on the same thread or queue it to a thread pool. You don't know which is going to happen.

You aren't waiting for the task to complete, so if it gets queued to a thread pool, your function is going to release the lock and return, potentially before the work has even started.

In general, best practice is to only acquire locks for as little time as needed, and never keep a lock held while waiting for another thread, as you can end up with a deadlock very easily if you aren't extremely careful.

Answer 2

There isn't a best way between these two, you just obtain 2 different results:

In the first case, you won't start a task till the lock is opened.

In the second case you will start a task which won't do anything till the lock is opened.

In my opinion not opening a task till you need it, is a better approach, but it's just a personal opinion. Opening and locking after, will allocate useless resources.