Опасности ThreadLocal

Языки и рамки развиваются. Мы, как разработчики, должны постоянно узнавать что-то новое и отучиться от уже освоенных знаний. Говоря за себя, обучение является самой трудной частью непрерывного обучения. Когда я впервые столкнулся с многопоточными приложениями в .NET, я наткнулся на атрибут ThreadStatic . Я помнил, что этот атрибут особенно полезен, когда у вас есть статические поля, которые не должны быть общими для потоков. В то время, когда была выпущена .NET Framework 4.0, я обнаружил класс ThreadLocal и то, как он лучше справляется с назначением значений по умолчанию для данных, специфичных для потока. Итак, я отучился ThreadStaticAttribute, отдавая предпочтение ThreadLocal<T>.

Быстро перенесемся на некоторое время спустя, когда я начал копаться async/await. Я стал жертвой убеждения, что данные, относящиеся к потокам, все еще работают. Итак, я снова был неправ, и мне пришлось снова учиться! Если бы я только знал об AsyncLocal ранее.

Давайте учиться и не учиться вместе!

TL; DR

• А Taskэто не а Thread. Taskэто будущее или обещание, которое в конечном итоге исполняется работником Thread.
• Если вам нужны окружающие данные, локальные для асинхронного потока управления, например, для кэширования каналов связи WCF, используйте AsyncLocalвместо .NET 4.6 или Core CLR ThreadStaticAttributeили ThreadLocalпредоставьте его.

Ложки нет

Некоторые вещи просто запоминаются. Когда мир вокруг нас развивается, эти вещи могут перестать быть правдой. Все мы, кто начинал программировать на .NET в эпоху, предшествующую .NET 4.0, синтезировали знания о потоках и их полезности при параллельном выполнении интенсивных операций. Мы знали разницу между потоками переднего плана и фона и насколько важно не блокировать поток пользовательского интерфейса.

Затем была выпущена библиотека параллельных задач, которая перевернула наш мир с ног на голову. Глядя на это System.Threading.Tasks.Task, мы внезапно почувствовали себя как Нео из Матрицы и поняли, что ложки нет — или, в нашем контексте, нет Thread!

Я не первый, кто использует аналогию Matrix для описания разницы между a Threadи a Task. У Стивена Клири отличная публикация. Нет темы от 2013 года, которая использует ту же аналогию и углубляется в различия. Я настоятельно рекомендую прочитать это.

А Taskпод параллельной библиотекой задач — это будущее или обещание . А Taskэто то, что вы хотите сделать. Напротив, это Threadодин из многих возможных работников, которые могут выполнить эту задачу. По контракту a Taskмы не знаем, будет ли это запланировано, будет ли оно выполнено немедленно или уже выполнено в тот момент, когда мы объявили это. Среда выполнения параллельной библиотеки задач имеет встроенные смарт-коды, позволяющие решить, будет ли задача выполняться в потоке, который ее создал, или ее нужно запланировать в пуле рабочих потоков или пуле потоков ввода-вывода. Более того, то, что поток работал над заданной задачей, не означает, что поток выполнит все продолжения этой задачи.

Это становится еще сложнее, когда мы начинаем вводить async / await в уравнение. Каждый раз, когда вы пишете awaitоператор вместе с вашим другомConfigureAwait(false) , поток, выполняющий задачу в данный момент, может вернуться назад и начать выполнять несколько других задач. Когда операция ввода / вывода завершается, оставшаяся часть задачи (продолжение) снова назначается Taskответственным в данный момент TaskScheduler. Ранее ответственный поток мог взять эту задачу и продолжить работу над ней. Альтернативно, любой другой доступный поток мог сделать это. Следующий код иллюстрирует это:

static dynamic Local;
static ThreadLocal<string> ThreadLocal = new ThreadLocal<string>(() => "Initial Value");

public async Task ThereIsNoSpoon()
{
    // Assign the ThreadLocal to the dynamic field
    Local = ThreadLocal;

    Console.WriteLine($"Before TopOne: '{Local.Value}'");
    await TopOne().ConfigureAwait(false);
    Console.WriteLine($"After TopOne: '{Local.Value}'");
    await TopTen().ConfigureAwait(false);
    Console.WriteLine($"After TopTen: '{Local.Value}'");
}

static async Task TopOne()
{
   await Task.Delay(10).ConfigureAwait(false);
   Local.Value = "ValueSetBy TopOne";
   await Somewhere().ConfigureAwait(false);
}

static async Task TopTen()
{
   await Task.Delay(10).ConfigureAwait(false);
   Local.Value = "ValueSetBy TopTen";
   await Somewhere().ConfigureAwait(false);
}

static async Task Somewhere()
{
   await Task.Delay(10).ConfigureAwait(false);
   Console.WriteLine($"Inside Somewhere: '{Local.Value}'");
   await Task.Delay(10).ConfigureAwait(false);
   await DeepDown();
}

static async Task DeepDown()
{
   await Task.Delay(10).ConfigureAwait(false);
   Console.WriteLine($"Inside DeepDown: '{Local.Value}'");
   Fire().Ignore();
}

static async Task Fire()
{
   await Task.Yield();
   Console.WriteLine($"Inside Fire: '{Local.Value}'");
}

Before TopOne: 'Initial Value'
Inside Somewhere: 'ValueSetBy TopOne'
Inside DeepDown: 'ValueSetBy TopOne'
After TopOne: 'ValueSetBy TopOne'
Inside Fire: 'Initial Value'
Inside Somewhere: 'Initial Value'
Inside DeepDown: 'ValueSetBy TopTen'
Inside Fire: 'Initial Value'
After TopTen: 'ValueSetBy TopTen'

static AsyncLocal<string> AsyncLocal = new AsyncLocal<string> { Value = "Initial Value" };

public async Task BendItWithYourMind()
{
    // Assign the AsyncLocal to the dynamic field
    Local = AsyncLocal;

    // This code is the same as before but shown again for clarity
    Console.WriteLine($"Before TopOne: '{Local.Value}'");
    await TopOne().ConfigureAwait(false);
    Console.WriteLine($"After TopOne: '{Local.Value}'");
    await TopTen().ConfigureAwait(false);
    Console.WriteLine($"After TopTen: '{Local.Value}'");
}

Before TopOne: 'Initial Value'
Inside Somewhere: 'ValueSetBy TopOne'
Inside DeepDown: 'ValueSetBy TopOne'
After TopOne: 'Initial Value'
Inside Fire: 'ValueSetBy TopOne'
Inside Somewhere: 'ValueSetBy TopTen'
Inside DeepDown: 'ValueSetBy TopTen'
Inside Fire: 'ValueSetBy TopTen'
After TopTen: 'Initial Value'