C# (C Sharp) programming on Telegram: “🛠️ Задача с подвохом: Ленивая инициализация и л…”

🛠️ Задача с подвохом: Ленивая инициализация и ловушка многопоточности

Условие:

У вас есть следующий код:


using System;
using System.Threading;

class Program
{
    static Lazy<HeavyObject> _heavy = new Lazy<HeavyObject>(() =>
    {
        Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] Initializing HeavyObject...");
        return new HeavyObject();
    });

    static void Main()
    {
        for (int i = 0; i < 5; i++)
        {
            new Thread(() =>
            {
                Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] Accessing HeavyObject...");
                var obj = _heavy.Value;
            }).Start();
        }

        Console.ReadLine();
    }
}

class HeavyObject
{
    public HeavyObject()
    {
        Thread.Sleep(1000);  // эмуляция долгой инициализации
        Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] HeavyObject created.");
    }
}

❓ Вопрос:
Сколько раз вы увидите сообщение Initializing HeavyObject... и HeavyObject created.? Почему это может удивить даже опытных .NET разработчиков?

🔍 Разбор:

На первый взгляд вы ожидаете, что:

- `Lazy<T>` гарантирует **ленивую инициализацию один раз** даже при многопоточном доступе.
- Сообщение `Initializing HeavyObject...` и конструктор `HeavyObject` сработают только один раз.

Но! Тут есть подвох.

По умолчанию `Lazy<T>` использует **LazyThreadSafetyMode.ExecutionAndPublication**. Это гарантирует, что даже если несколько потоков обращаются к `.Value` одновременно, объект будет инициализирован **только один раз**.

✅ **Ожидаемый вывод:**

- Каждый поток пишет `Accessing HeavyObject...`
- Только один поток пишет `Initializing HeavyObject...` и `HeavyObject created.`
- Остальные потоки дождутся завершения и получат уже готовый объект.

Примерный вывод:

```
[4] Accessing HeavyObject...
[5] Accessing HeavyObject...
[6] Accessing HeavyObject...
[7] Accessing HeavyObject...
[8] Accessing HeavyObject...
[4] Initializing HeavyObject...
[4] HeavyObject created.
```

🌀 **Подвох, если сменить режим:**

Если вы немного измените код вот так:

```csharp
static Lazy<HeavyObject> _heavy = new Lazy<HeavyObject>(
() =>
{
Console.WriteLine($"[{Thread.CurrentThread.ManagedThreadId}] Initializing HeavyObject...");
return new HeavyObject();
},
LazyThreadSafetyMode.None // без потокобезопасности
);
```

То при **одновременном** доступе к `.Value` вы получите **несколько инициализаций** (по сути гонку потоков).

Примерный вывод может быть таким:

```
[4] Accessing HeavyObject...
[5] Accessing HeavyObject...
[6] Accessing HeavyObject...
[4] Initializing HeavyObject...
[5] Initializing HeavyObject...
[6] Initializing HeavyObject...
[4] HeavyObject created.
[5] HeavyObject created.
[6] HeavyObject created.
```

Итого объект будет создан несколько раз, что ломает инварианты "Lazy должен создавать объект один раз".

✅ **Вывод:**

• По умолчанию `Lazy<T>` **потокобезопасен**, но важно понимать, что это можно **изменить**.
• При работе с многопоточностью в .NET всегда обращайте внимание на **режим LazyThreadSafetyMode**.
• Даже опытные разработчики могут не заметить подвоха, если кто-то по ошибке или из оптимизаций использует `LazyThreadSafetyMode.None`.

💡 **Бонус-вопрос:**
Что произойдёт, если ваш factory-метод (лямбда) выбросит исключение при инициализации? Как `Lazy<T>` поведёт себя при следующем доступе к .Value?

@csharp_ci