C# Double-Checked Locking: Güvenli Mi?

Selamlar, developer dünyasında, çoklu iş parçacıklı programlamada (Multithreading) güvenlik, kritik bir öneme sahiptir. Ancak, bazı desenler (Pattern) ve yöntemler, göründüğü kadar güvenli olmayabilir. C# dilinde sıkça başvurulan bir desen olan “Double-Checked Locking”in gerçekte ne kadar güvenli olduğunu sorgulamaya başlayalım.

Bu makalede, double-checked locking’in çözümlenmesi gereken güvenlik sorunlarına ve bunlardan kaçınma yollarına odaklanacağız.

Elbette yazıda fark edeceğiniz ve benimde “şurayı detaylandırabilirim” dediğim bir kaç yer var. Anlatmak istediğim konunun da dışına çıkmak istemediğim ve konunun dağılmaması için olabildiğince sadece detaylandırmaya çalıştım.

Güvenli Yöntemler

Detayına ileride gireceğiz. Yazının başında bu noktayı merak edenler için paylaşmış olalım. Bu sorunu çözmek için, volatile anahtar kelimesi veya Lazy<T> sınıfı C# dilinde kullanılabilir. Bu, uygun bellek bariyerlerini sağlamak ve talimatların yeniden düzenlenmesini önlemek için kullanılır.

Double-Checked Locking Nedir?

Bir nesnenin, yani bir sınıfın örneğini (instance) yaratmayı kontrol etmek için kilit mekanizması kullanılan bir programlama desenidir. Bu desen (Singleton), performans optimizasyonu sağlamak amacıyla ilk kontrolü kilit dışında, ikinci kontrolü ise kilit içinde gerçekleştirir. Ancak, bu desenin doğrudan uygulanması bazı dillerde ve koşullarda thread safety sorunlarına neden olabilir.

C# dilinde double-checked locking kullanarak bir singleton nesnesi yaratma örneği:

public class Singleton
{
    private static Singleton instance;
    private static readonly object lockObject = new object();

    public static Singleton Instance
    {
        get
        {
            if (instance == null) // İlk kontrol
            {
                lock (lockObject) // Kilit mekanizması
                {
                    if (instance == null) // İkinci kontrol
                    {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }
}

Bu örnekte, Singleton sınıfı içinde Instance özelliği aracılığıyla bir sınıf oluşturuyoruz. İlk kontrol (if (instance == null)) kilit (lock) dışında gerçekleşir. Eğer instance null ise, kilidi alıp ikinci kontrolü (if (instance == null)) gerçekleştirir. Bu ikinci kontrol kilit içinde yapılır ve bu şekilde yalnızca bir iş parçacığının bir nesneyi oluşturması sağlanır.

Neden Güvenli Değil?

Geleneksel double-checked locking yaklaşımı, talimatların yeniden düzenlenmesi (Instruction Reordering) ve CPU’nun içsel optimizasyonları (Microarchitecture Optimizations) nedeniyle thread-safe değildir.

Bu terimlerin detaylarına ileride giricez.

Thread 1:

if (instance == null) // ilk kontrol

Thread 2:

if (instance == null) // ikinci kontrol

Thread 1:

lock (lockObject)

Thread 2:

lock (lockObject)

Thread 1:

if (instance == null) // kilidin içindeki üçüncü kontrol
{
    instance = new Singleton();
}

Thread 2:

if (instance == null) // kilidin içindeki dördüncü kontrol
{
    instance = new Singleton();
}

Burada, Thread 1 ve Thread 2 aynı anda instance'ı kontrol edebilirler. İlk kontroller (ilk kontrol ve ikinci kontrol) başarılı olabilir ve ardından her iki iş parçacığı da kilit alır (lockObject). Ardından, her iki iş parçacığı da ikinci kontrolü gerçekleştirir (üçüncü kontrol ve dördüncü kontrol). Bu durumda, her iki iş parçacığı da instance'ı oluşturabilir, bu da “double-checked locking” yaklaşımının güvenli olmadığını gösterir.

Bu durumun temel nedeni, .NET runtime ve C# dilinin bellek bariyerlerini ve talimatların yeniden düzenlenmesini, performans optimizasyonu için nasıl ele aldığıdır. CLR (Common Language Runtime) ve C# derleyicisi (compiler) talimatları yeniden düzenleyebilir; bu, çoklu iş parçacıklı bir ortamda beklenmeyen davranışlara neden olabilir.

Talimat (Instruction) Derken Ne Demek İsteniyor?

Yazıda sıkça “Talimat” kelimesi geçecek. Bu konuyu açıklamak istedim, çünkü “Türkçe” terimleri kullanırken karışıklıklar olabiliyor. Bunu detaylandıralım.

“Talimat” terimi, bilgisayar programlamasında bir işlemi ifade eden, temel komutları ifade eder. İşlemci tarafından doğrudan anlaşılabilir ve yürütülebilir olan komutlardır. Her dilin derlenmiş kodu, bu temel talimatları içerir.

Örneğin, bir C# döngüsündeki talimatlar:

for (int i = 0; i < 5; i++)
{
    Console.WriteLine("Sayı: " + i);
}

Bu döngü, birkaç temel talimat içerir:

1. int i = 0;: Bu, bir değişkenin başlatılması talimatıdır.
2. i < 5;: Bu, döngünün devam etme koşulunu kontrol eden bir talimattır.
3. i++: Bu, döngü değişkeninin bir artırma talimatıdır.
4. Console.WriteLine("Sayı: " + i);: Bu, ekrana bir çıktı yazdırma talimatıdır.

Bunlar, temel bilgisayar işlemlerini ifade eden talimatlardır. Ancak, optimizasyonlar sırasında, CLR ve derleyici, bu talimatları daha etkin bir şekilde düzenleyebilir. Örneğin, yukarıdaki döngüyü optimize etmek amacıyla talimatların sırasını değiştirebilir ve işlemci tarafından daha verimli bir şekilde yürütülebilecek hale getirebilir.

C# derleyicisi (compiler) ve CLR (Common Language Runtime)

C# Derleyicisi (Compiler)

C# derleyicisi, yazılan C# kodunu anlamak, kontrol etmek ve IL (Intermediate Language) koduna derlemekle görevlidir.

CLR (Common Language Runtime)

• Açıklama: CLR, .NET platformunda çalışan bir sanal makine ve çalışma zamanı ortamını temsil eder. Bu, yüksek seviyeli dil kodunu (C#, VB.NET gibi) çalıştıran ve platforma özgü makine koduna çeviren bir bileşendir.
• Örnek: Bir C# programı yazıldığında, C# derleyicisi tarafından oluşturulan ara ürün IL (Intermediate Language) kodudur. CLR, bu IL kodunu çalışma sırasında platforma özgü makine koduna çevirir.

Talimatların Yeniden Düzenlenmesi (Instruction Reordering)

Talimatların yeniden düzenlenmesi (Instruction Reordering), bir derleyicinin veya işlemcinin, bir programdaki talimatlarının sırasını değiştirerek, çalışma şeklini iyileştirmeye yönelik bir optimizasyon tekniğidir. Ancak, bu optimizasyonlar bazen beklenmeyen davranışlara yol açabilir, özellikle çoklu iş parçacıklı ortamlarda.

Örnek olarak, aşağıdaki C# kodu üzerinden devam edelim:

class Example
{
    private int x = 0;
    private bool flag = false;

    void Thread1()
    {
        x = 42;         // İşlem 1
        flag = true;    // İşlem 2
    }

    void Thread2()
    {
        if (flag)       // İşlem 3
            Console.WriteLine(x);   // İşlem 4
    }
}

Bu kod, iki farklı iş parçacığı tarafından aynı nesne üzerinde çalışan basit bir senaryoyu temsil ettiğini düşünelim. Ancak, bu kodun belirli bir sırayla çalıştığı varsayılır. Derleyiciler veya işlemciler, optimize etmek veya performansı artırmak amacıyla bu sıralamayı değiştirebilir.

1. Reordering örneği:

// Thread1'in derlenmiş kodu
x = 42;          // İşlem 1
flag = true;     // İşlem 2

// Thread2'nin derlenmiş kodu
if (flag)        // İşlem 3
    Console.WriteLine(x);   // İşlem 4

Burada, işlemciler x'in değerini değiştirmeden önce flag'i true olarak değerlendirebilirler, bu da beklenmeyen bir duruma yol açabilir.

2. Compiler Optimization örneği:

// Thread1'in derlenmiş kodu
flag = true;     // İşlem 2
x = 42;          // İşlem 1

// Thread2'nin derlenmiş kodu
if (flag)        // İşlem 3
    Console.WriteLine(x);   // İşlem 4

Burada, derleyici, x'in değerini değiştirmenin flag'i true olarak ayarlamaktan önce gerçekleştiğini fark edebilir ve bu nedenle sırayı değiştirebilir.

CPU’nun İçsel Optimizasyonları (Microarchitecture Optimizations)

CPU’nun içsel optimizasyonları, işlemcinin performansını artırmak ve enerji verimliliğini sağlamak amacıyla kullanılan bir dizi teknik ve stratejiyi temsil eder. İçsel optimizasyonlar, işlemcinin çalışma hızını artırmak, önbellek kullanımını optimize etmek ve güç tüketimini düşürmek gibi hedeflere odaklanır.

Bu konuyu basit bir şekilde açıklamak istedim; yukarıda bahsedilenler, içsel optimizasyonların neden önemli olduğunu anlatan temel sebeplerden sadece birkaçıdır.

Thread-Safe Yöntemler

Bu sorunu çözmek için, volatile anahtar kelimesi veya Lazy<T> sınıfı C# dilinde kullanılabilir. Bu, uygun bellek bariyerlerini sağlamak ve talimatların yeniden düzenlenmesini önlemek için kullanılır.

Lazy Initialization:

Kullanımı:

public class Singleton
{
    private static readonly Lazy<Singleton> lazyInstance = new Lazy<Singleton>(() => new Singleton());
    public static Singleton Instance => lazyInstance.Value;
}

Avantajlar:

1. Performans İyileştirmesi: Nesne yalnızca ihtiyaç duyulduğunda oluşturulduğu için başlatma süresini iyileştirebilir.
2. Thread Safety: Lazy<T> sınıfı, nesnenin oluşturulması sürecini thread-safe bir şekilde yönetir.
3. Tekil Nesne Muhafazası: Singleton tasarım desenini uygulamak için uygun bir yöntemdir.

Dezavantajlar:

1. Karmaşıklık: Uygulamaya gereksiz karmaşıklık ekleyebilir.
2. Bağlam Değişimi Sorunları: Bazı durumlarda bağlam değişimi sorunlarına neden olabilir. Örneğin, .NET’te ExecutionContext gibi bağlam nesneleri, iş parçacıkları arasında veri taşır. Lazy Initialization kullanılıyorsa ve bu bağlam nesneleri değişirse, beklenmeyen sonuçlar ortaya çıkabilir.

Volatile Anahtar Kelimesi:

Kullanımı:

public class Singleton
{
    private static volatile Singleton instance;
    private static readonly object lockObject = new object();

    private Singleton() { }

    public static Singleton Instance
    {
        get
        {
            if (instance == null)
            {
                lock (lockObject)
                {
                    if (instance == null)
                    {
                        instance = new Singleton();
                    }
                }
            }
            return instance;
        }
    }
}

Avantajlar:

1. Thread Safety: Volatile, bir değişkenin değerini bir iş parçacığında değiştiren bir iş parçacığı tarafından, diğer iş parçacıklarına hemen görünür hale getirir, bu nedenle thread safety sağlar. Umarım cümle anlaşılmıştır :)
2. Basit Kullanım: volatile anahtar kelimesi kullanmak, Lazy Initialization'a kıyasla daha basit bir yaklaşımdır.

Dezavantajlar:

1. Performans: Performans kaybına neden olabilir, çünkü değişkenin her kullanımında hemen hemen her zaman ana bellekteki değeri almak zorunda kalır.
2. Tekil Nesne Muhafazası: Singleton tasarım desenini uygulamak için doğrudan bir destek sağlamaz.

Bonus

Aynı zamanda Lazy<T> sınıfının asenkron bir versiyonu olan Lazy<Task<T>> tipinide kullanabiliriz. Bunun içinde bir örnek paylaşmış olalım.

Öncesinde Lazy<Task<T>> sınıfını genişletelim.

public class AsyncLazy<T> : Lazy<Task<T>>
{
    public AsyncLazy(Func<T> valueFactory) :
        base(() => Task.Factory.StartNew(valueFactory)) { }

    public AsyncLazy(Func<Task<T>> taskFactory) :
        base(() => Task.Factory.StartNew(() => taskFactory()).Unwrap()) { }

    public TaskAwaiter<T> GetAwaiter() { return Value.GetAwaiter(); }
}

Aşağıdaki örnek ile devam edelim. Verdiğimiz bir url içeriğini çeken kod parçası;

static AsyncLazy<string> m_data = new AsyncLazy<string>(async delegate
{
    WebClient client = new WebClient();
    return (await client.DownloadStringTaskAsync(someUrl)).ToUpper();
});

Basitçe çağrılması;

string result = await m_data;

Umarım faydalı olmuştur. Başka bir yazıda görüşmek üzere :)

KA

Kaynaklar

https://mortoray.com/cpu-reordering-what-is-actually-being-reordered/

https://csharpindepth.com/Articles/Singleton#dcl

https://www.baeldung.com/java-singleton-double-checked-locking

https://www.oracle.com/technical-resources/articles/javase/bloch-effective-08-qa.html

Double-checked locking in .NET

https://devblogs.microsoft.com/pfxteam/asynclazyt/