Execute a piece of code in one run without blocking it for other parallel threads

Let's say you have piece of code within a method, which doesn't use any critical resources, but you want to execute it in one run, because you want to make sure, that the code is executed as fast as possible without any pause due to scheduling.

If you would take lock or SemaphoreSlim like bellow, the code within them will be blocked for every other thread which would run parallel and that would have a negative impact on performance. Of course SemaphoreSlim offers the possibility to define number of parallel threads, but I don't want to manage it by myself.

private readonly object myLock = new object();
lock (this.teamLock)
{
  // ... code
}
// 
private readonly SemaphoreSlim semaphore = new SemaphoreSlim(1, 1);

public async Task LockAsync(Func<Task> worker)
{
    await semaphore.WaitAsync();
    try
    {
        // ... code
    }
    finally
    {
        semaphore.Release();
    }
}

Is there another way to make sure, that a code is executed in one run?

TL;DR: you probably don't want to do it, and even if you do it's probably not woth it.

.NET threads are backed by OS threads, which use preemptive scheduling (and what you're asking is how to prevent preemption).

You can prevent other threads from running in the same app by suspending them. You'd need to drop down to the Win32 level in order to enumerate and suspend them. This can cause deadlocks if you want to run managed code, though, since the runtime in general assumes its threads are running. And there's still all the other threads from other apps.

Alternatively, if you're on Windows, you can raise your thread priority above the realtime level to avoid other threads getting dynamic priority boosts up to the same level as your thread. This is not recommended in general, though, and that goes double for managed code, for the same reasons as the deadlock above. The lack of dynamic boosting can cause deadlocks unless you are very careful. Use of realtime priorities require a complete understanding of all your dependencies and how they interact with a realtime priority thread.

So, while it's technically possible, it's quite a bit of work; and it really should not be managed code at all, since the runtime isn't designed for this. You would rewrite it as unmanaged code and then run it in a separate realtime process. And then verify that your dependencies will work as expected.

> you want to execute it in one run, because you want to make sure, that the code is executed as fast as possible without any pause due to scheduling.

Actually, what you should probably do is lower the priority, or just leave it the default. Dynamic priority boosts will automatically do what's best for the user. If anything, if you have a CPU-bound method that takes a noticeable amount of time, consider lowering the priority.