Delphi Can

Orjinalini görmek için tıklayınız: Tasarım Desenleri : Singleton Design
Şu anda (Arşiv) modunu görüntülemektesiniz. Orjinal Sürümü Görüntüle internal link
Sayfalar: 1 2
(09-10-2017, Saat: 16:28)edo Adlı Kullanıcıdan Alıntı: [ -> ]Thread içinden GetInstance metodu çağrıldığında birden fazla Instance oluşmaması için yani Pattern'in Thread Safety olarak kullanılabilmesi için böyle bir şeye gerek olduğunu hatırlatmak istemiştim.

Yazınız için teşekkürler bu arada, eminim faydalı olacaktır.

edo'nun da bahsettiği gibi Singleton kalıbına double check ve thread safety sağlanır ise istenilen amaç daha stabil elde edilebilir. Double check aynı kod bloğuna birden fazla thread'in girmesi durumunda ve bu thread'lerin zamanlanması durumunda etkili olur. Tek başına double check'de yetmez. Bu bağlamda;

  if not Assigned(AInstance) then
  begin
    EnterCriticalSection;

      if not Assigned(AInstance) then
        AInstance := TMyInstance.Create;

    LeaveCriticalSection;
  end;

  Result := AInstance;


gibi bir kod yazmamız gerekir. Merak eden arkadaşlar, "double check" araması yaparak nedenlerini detaylıca irdeleyebilirler.
Yazının devamına geçmeden önce aşağıdaki linkte yer alan konuyu bir gözden geçirmek faydalı olabilir. 

https://blogs.msdn.microsoft.com/ericlip...read-safe/

Ben Thread'ler konusunda uzman değilim (nasipse bir gün...) ve bu kapsamda yazdıklarımın bu noktada biraz "şüpheyle karşılanması gerektiğini" açıkça belirtmek isterim. Her ne kadar Low Level bir konu olsa da şu an kafamda bazı sorular ve bazı cevaplar var ve bunu bir topluluk olarak burada müzakere etmenin, tartmanın, tartışmanın gerekli ve öğretici olduğuna inanıyorum. O nedenle bu konuda bilgili olan arkadaşlarımın yorumları sadece benim için değil, herkes için önemli.

Thread Safery işin içine girince doğal olarak Patternin bazı bölümlerinde değişiklik yapma gereği duydum. @EDO'nun belirttiği şerh, bazı testler yapmak için beni tetikledi, @Tuğrul HELVACI'nın önerisi de daha çok araştırma yapmam konusunda teşvik edici oldu. Dolayısıyla bu noktada Singleton Patterni'nin istediğimiz kadar örneğini çeksek bile bize hep ilk oluşturduğumuz TSingletonOrnegi nesnesinin değerlerini getirmesi gerektiği sonucuna vardım. tekilliğin sağlanması adına bunun yeterli olacağını düşünüyorum. Bu arada herhangi bir thread'den de nesneye olan erişimin kısıtlanmaması daha şık olur düşüncesindeyim. Zira araştırmalarım sırasında webde karşılaştığım örneklerin bir çoğu bu konuya bu kadar hassas yaklaşmamış...

Desen ilk başka thread safery olarak gözükmeyebilir ama öyle

Bu hedefi gerçekleştirmek için patternin yapısında bazı değişiklikler yaptım ve daha özgün bir yapı ortaya çıktı. Ayrıca test etmek için Singleton Patternini içeren bir uygulama da yazdım. Yorumlarınız bu testleri daha gerçekçi hale getirecektir.

uygulamayı çalıştırdığımızda TSingletonOrnegi.TEST_DATA değişkeninin bellek adresinin değişmediğine özellikle dikkat etmenizi istiyorum.

Kaynak kodları aşağıdaki linkten edinebilirsiniz; (10.2 Tokyo ile oluşturuldu)

http://s6.dosya.tc/server11/vpaowv/DENEY...3.rar.html

Uygulamada 3 adet buton, 1 adet toggle switch, bir timer ve son olarak bir memo bileşeni var, 1. buton yerel bir değişken olarak singleton nesnesi üretiyor ve bunun test_data değişkenini değiştiriyor. 2. buton ise peş peşe 10 adet anonim kanal oluşturup aynı işi yapıyor, sonuncu buton ise global bir tsingleton nesnesi oluşturuyor. Timer de aynı şeyi 3 saniyede bir bir kanal oluşturarak tekrarlayıp duruyor...

Örnek uygulamada TSingletonOrnegi.TEST_DATA adlı değişkenin adresinin hangi kopyadan erişilirse erişilsin her zaman aynı bellek adresinde işlem görmesi sağlanıyor aslında... Böylece Signleton Patterni, thread-safety anlamında uyumlu olmuş oluyor.

Önce Signleton Patterninin thread Safety uyumlu olan aşağıdaki örneğini kod üzerinden inceleyelim;

...
type

  TSingletonOrnegi = class
  strict private
    class function Create: TSingletonOrnegi;         // Aslında bu bir hile, klasik kullanımda bir Constructor tanımlamamız gerekirdi
    class var FInstance: TSingletonOrnegi;           // Sınıf değişkenimiz, tekilliği sağlamak için bunu kullanacağız.
  public
    TEST_DATA: String;                               // Bu değişken ile testlerimizi gerçekleştireceğiz, bunu sınıfı üretmeden (Create etmeden) kullanamayız.
    class function GetInstance: TSingletonOrnegi;    // Sonuç itibariyle bize FInstance değişkeninin canlı örneğini verecek
    destructor Destroy; override;                    // Yokedicimiz...
  end;

var
  Form1: TForm1;
  GlobalSingleton: TSingletonOrnegi;
  KureselSingleton: TSingletonOrnegi;

implementation

{$R *.dfm}


{ TSingleton }

class function TSingletonOrnegi.Create: TSingletonOrnegi;
begin
  // Bu fonksiyonu kod tamamlayıcıdan gizlemek için Strict Private bölümünde tanımlamıştık.
  if (GetCurrentThreadId = System.MainThreadID) then begin        // Ana Thread'de isek (yani uygulamanın ta kendisindeysek)
      if (TSingletonOrnegi.FInstance = nil) then begin            // Sınıf değişkeni atanmamış ise
          TSingletonOrnegi.FInstance := inherited Create as Self; // Bu noktada sınıfı oluşturuyor ve sınıfın global değişkenine kendimizi atıyoruz...
      end;
      Result := TSingletonOrnegi.FInstance;                       // Sonuç...
  end;
  { BU NOKTADA KOD YAZARLARINA BU FONKSİYONU DOĞRUDAN ÇAĞIRMAMALARI GEREKTİĞİYLE İLGİLİ UYARIYI YAZMAK GEREKİR... }
  // > UYARI : BU KISMI DOĞRUDAN ÇAĞIRMAK MEMORY LEAK OLUŞMASINA SEBEP OLUR. LÜTFEN GETINSTANCE FONKSİYONUNU KULLANIN...
  // gibi...
end;

class function TSingletonOrnegi.GetInstance: TSingletonOrnegi;
begin
  if not Assigned(TSingletonOrnegi.FInstance) then begin
      Result := TSingletonOrnegi.Create as Self; // sınıf içinden çağırdığımız için asıl constructor olan "TObject.Create" metodunu değil, yukarıda kendi yazdığımız fonksiyon çağırmış olduk...
  end;
  Result := TSingletonOrnegi.FInstance;
end;

destructor TSingletonOrnegi.Destroy;
begin
  TSingletonOrnegi.FInstance := nil;
  inherited;
end;


Bu da programın ekran görüntüsü

ROQjl1.png

Aşağıda da uygulamanın kaynak kodları yer almaktadır.

unit Unit1;

interface

uses
 Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
 Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Vcl.ExtCtrls,
 Vcl.WinXCtrls;

type
 TSingletonOrnegi = class
 strict private
   class function Create: TSingletonOrnegi;         // Aslında bu bir hile, klasik kullanımda bir Constructor tanımlamamız gerekirdi
   class var FInstance: TSingletonOrnegi;           // Sınıf değişkenimiz, tekilliği sağlamak için bunu kullanacağız.
 public
   TEST_DATA: String;                               // Bu değişken ile testlerimizi gerçekleştireceğiz, bunu sınıfı üretmeden (Create etmeden) kullanamayız.
   class function GetInstance: TSingletonOrnegi;    // Sonuç itibariyle bize FInstance değişkeninin canlı örneğini verecek
   destructor Destroy; override;                    // Yokedicimiz...
 end;

 TForm1 = class(TForm)
   Timer1: TTimer;
   Button1: TButton;
   Button2: TButton;
   Button3: TButton;
   Memo1: TMemo;
   Toggle: TToggleSwitch;
   procedure FormCreate(Sender: TObject);
   procedure FormDestroy(Sender: TObject);
   procedure Timer1Timer(Sender: TObject);
   procedure Button1Click(Sender: TObject);
   procedure Button2Click(Sender: TObject);
   procedure Button3Click(Sender: TObject);
 private
   { Private declarations }
 public
   { Public declarations }
 end;

var
 Form1: TForm1;                              // Test yapacağımız uygulamanın ana formu
 GlobalSingleton : TSingletonOrnegi;         // Uygulama ilk oluşturulduğunda bu da oluşacak (aslında biz "GetInstance" dediğimizde hep bunu çekmiş olacağız...)
 KureselSingleton: TSingletonOrnegi;         // Nitelik açısından "GlobalSingleton" ile hiç bir farkı yok, tek fark bunu "sonradan" üreteceğiz...
 KritikBolge     : TRTLCriticalSection;      // Thread'leri kullanırken diğer threadleri dizginlemek adına bunu kullanacağız...

implementation

{$R *.dfm}

{ TSingleton }

class function TSingletonOrnegi.Create: TSingletonOrnegi;
begin
 // Bu fonksiyonu kod tamamlayıcıdan gizlemek için Strict Private bölümünde tanımlamıştık.
 if (GetCurrentThreadId = System.MainThreadID) then begin        // Ana Thread'de isek (yani uygulamanın ta kendisindeysek)
     if (TSingletonOrnegi.FInstance = nil) then begin            // Sınıf değişkeni atanmamış ise
         TSingletonOrnegi.FInstance := inherited Create as Self; // Bu noktada sınıfı oluşturuyor ve sınıfın global değişkenine kendimizi atıyoruz...
     end;
     Result := TSingletonOrnegi.FInstance;                       // Sonuç...
 end;
 { BU NOKTADA KOD YAZARLARINA BU FONKSİYONU DOĞRUDAN ÇAĞIRMAMALARI GEREKTİĞİYLE İLGİLİ UYARIYI YAZMAK GEREKİR... }
 // > UYARI : BU KISMI DOĞRUDAN ÇAĞIRMAK MEMORY LEAK OLUŞMASINA SEBEP OLUR. LÜTFEN GETINSTANCE FONKSİYONUNU KULLANIN...
 // gibi...
end;

class function TSingletonOrnegi.GetInstance: TSingletonOrnegi;
begin
 if not Assigned(TSingletonOrnegi.FInstance) then begin
     Result := TSingletonOrnegi.Create as Self; // sınıf içinden çağırdığımız için TObject.Create metodu değil, yukarıda kendi yazdığımız fonksiyon çağırılır...
 end;
 Result := TSingletonOrnegi.FInstance;
end;

destructor TSingletonOrnegi.Destroy;
begin
 TSingletonOrnegi.FInstance := nil;
 inherited;
end;

{ TForm1 }

procedure TForm1.Button1Click(Sender: TObject);
var
 YEREL_Singleton :  TSingletonOrnegi;
begin
 if (Toggle.State = tssOff) then Exit;

 // bu noktada ana thread'de yerel bir singleton örneği oluşturuyoruz
 YEREL_Singleton := TSingletonOrnegi.GetInstance;
 // Gerçekte TEST_DATA'nın önceki değerini (YEREL_Singleton'u "kullanarak" okuyoruz)
 Memo1.Lines.Add(Format('@%p YEREL_Singleton.TEST_DATA = %s', [addr(YEREL_Singleton.TEST_DATA), YEREL_Singleton.TEST_DATA]));
 // ve TEST_DATA değerini Yerel kopya üzerinden ( aslında GlobalSingleton'a) yazıyoruz.
 YEREL_Singleton.TEST_DATA := 'Button1Click';
 // Sonra TEST_DATA'nın son halini okuyup memo'ya yazıyoruz...
 Memo1.Lines.Add(Format('@%p YEREL_Singleton.TEST_DATA = %s', [addr(YEREL_Singleton.TEST_DATA), YEREL_Singleton.TEST_DATA]));
end;

procedure TForm1.Button2Click(Sender: TObject);
var
 I: Integer;
begin
 // bu noktada 10 adet anonim kanal oluşturup thread için yerel bir singleton örneği oluşturuyoruz ve test_data değerini yazıyoruz...
 if (Toggle.State = tssOff) then Exit;
 for I := 0 to 9 do begin
     TThread.CreateAnonymousThread
            ( procedure
              var
                ThreadSingletonu: TSingletonOrnegi;
              begin
                EnterCriticalSection(KritikBolge); // kritik bölgemizi başlatıyoruz / giriyoruz...
                try
                  try
                    ThreadSingletonu := TSingletonOrnegi.GetInstance;
                    Form1.Memo1.Lines.Add(Format('@%p ThreadSingletonu.TEST_DATA = %s', [addr(ThreadSingletonu.TEST_DATA), ThreadSingletonu.TEST_DATA]));
                    ThreadSingletonu.TEST_DATA := 'Button2Click';
                    Form1.Memo1.Lines.Add(Format('@%p ThreadSingletonu.TEST_DATA = %s', [addr(ThreadSingletonu.TEST_DATA), ThreadSingletonu.TEST_DATA]));
                  except on e: Exception do
                    begin
                      Form1.Memo1.Lines.Add('ThreadSingletonu ERROR > ' + E.Message);
                    end;
                  end;
                finally
                  LeaveCriticalSection(KritikBolge); // Kritik bölgeden ayrılıyoruz...
                end;
              end
            ).Start; // Varsayılan olarak "FreeOnTerminate := TRUE" olarak tanımlıdır. Dolayısıyla işi bittinde kendisini imha edecek...
 end;
end;

procedure TForm1.Button3Click(Sender: TObject);
begin
 // bu noktada KüreselSingleton adında yine ana thread'de GENEL bir singleton örneği oluşturuyoruz ve test_data değerini yazıyoruz...
 if (Toggle.State = tssOff) then Exit;
 KureselSingleton := TSingletonOrnegi.GetInstance;
 Memo1.Lines.Add(Format('@%p KureselSingleton.TEST_DATA = %s', [addr(KureselSingleton.TEST_DATA), KureselSingleton.TEST_DATA]));
 KureselSingleton.TEST_DATA := 'Button3Click';
 Memo1.Lines.Add(Format('@%p KureselSingleton.TEST_DATA = %s', [addr(KureselSingleton.TEST_DATA), KureselSingleton.TEST_DATA]));
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
 // bu noktada form ilk oluşturulduğunda GlobalSingleton adında ana thread'de GENEL bir singleton örneği oluşturuyoruz ve test_data değerini yazıyoruz...
 InitializeCriticalSection(KritikBolge); // Ön hazırlık...
 GlobalSingleton := TSingletonOrnegi.GetInstance;
 Memo1.Lines.Add(Format('@%p GlobalSingleton.TEST_DATA = %s', [addr(GlobalSingleton.TEST_DATA), GlobalSingleton.TEST_DATA]));
 GlobalSingleton.TEST_DATA := 'FormCreate';
 Memo1.Lines.Add(Format('@%p GlobalSingleton.TEST_DATA = %s', [addr(GlobalSingleton.TEST_DATA), GlobalSingleton.TEST_DATA]));
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
 GlobalSingleton.Destroy; // Bunun oluşturulmuş olması FormCreate olayından mütevellit "garanti" olduğu için sonlandırma sırasında bunu yok ediyoruz.
 // KureselSingleton.Destroy; // Bu satırda hata verecektir. Çünkü zaten yukarıdaki satırda singleton nesnemizi aslında yok ettik...
 DeleteCriticalSection(KritikBolge); // Çevre temizliği...
end;

procedure TForm1.Timer1Timer(Sender: TObject);
begin
 if (Toggle.State = tssOff) then Exit;
     TThread.CreateAnonymousThread
            ( procedure
              var
                AnonymousThreadSingletonu: TSingletonOrnegi;
              begin
                EnterCriticalSection(KritikBolge); // kritik bölgemizi başlatıyoruz / giriyoruz...
                try
                  try
                    AnonymousThreadSingletonu := TSingletonOrnegi.GetInstance;
                    Form1.Memo1.Lines.Add(Format('@%p AnonymousThreadSingletonu.TEST_DATA = %s', [addr(AnonymousThreadSingletonu.TEST_DATA), AnonymousThreadSingletonu.TEST_DATA]));
                    AnonymousThreadSingletonu.TEST_DATA := 'Timer1Timer';
                    Form1.Memo1.Lines.Add(Format('@%p AnonymousThreadSingletonu.TEST_DATA = %s', [addr(AnonymousThreadSingletonu.TEST_DATA), AnonymousThreadSingletonu.TEST_DATA]));
                  except on e: Exception do begin
                      Form1.Memo1.Lines.Add('AnonymousThreadSingletonu ERROR > ' + E.Message);
                    end;
                  end;
                finally
                  LeaveCriticalSection(KritikBolge); // Kritik bölgeden ayrılıyoruz...
                end;
              end
            ).Start; // Varsayılan olarak "FreeOnTerminate := TRUE" olarak tanımlıdır. Dolayısıyla işi bittinde kendisini imha edecek...
end;

end.
Tuğru hocamın yazdığı CriticalSection'ı sitesinde verdiğim linklerden incelerseniz kendisinin yazdığını kodun tamamen thread safety olduğunu görebilirsiniz
(16-10-2017, Saat: 17:44)edo Adlı Kullanıcıdan Alıntı: [ -> ]Tuğru hocamın yazdığı CriticalSection'ı sitesinde verdiğim linklerden incelerseniz kendisinin yazdığını kodun tamamen thread safety olduğunu görebilirsiniz

Yukarıdaki yazıma kullanım ile ilgili kodları da ekledim. Ayrıca resim üzerinde bazı alanları yeniden vurguladım. Şu noktada bana göre yukarıdaki kodlar bir Singleton tasarım deseninin tüm gereksinimlerini karşılıyor. Bununla birlikte thread açısından da güvenli olmadığını daha önceki postunuzda da belirtmiştiniz onunla ilgili olarak da yukarıdaki kodlar bu eksiği tamamlar nitelikte. Bu durumda siz "Thread Safety" derken tam olarak neyi kastediyorsunuz? Thread güvensiz ise bununla alakalı olarak sizden bu noktada "sizin" bir ispat belirtmeniz gerekir, Yanlış anlamayın ama ben burada neyi kaçırıyorum anlamadım?
(16-10-2017, Saat: 20:19)uparlayan Adlı Kullanıcıdan Alıntı: [ -> ]
(16-10-2017, Saat: 17:44)edo Adlı Kullanıcıdan Alıntı: [ -> ]Tuğru hocamın yazdığı CriticalSection'ı sitesinde verdiğim linklerden incelerseniz kendisinin yazdığını kodun tamamen thread safety olduğunu görebilirsiniz

Yukarıdaki yazıma kullanım ile ilgili kodları da ekledim. Ayrıca resim üzerinde bazı alanları yeniden vurguladım. Şu noktada bana göre yukarıdaki kodlar bir Singleton tasarım deseninin tüm gereksinimlerini karşılıyor. Bununla birlikte thread açısından da güvenli olmadığını daha önceki postunuzda da belirtmiştiniz onunla ilgili olarak da yukarıdaki kodlar bu eksiği tamamlar nitelikte. Bu durumda siz "Thread Safety" derken tam olarak neyi kastediyorsunuz? Thread güvensiz ise bununla alakalı olarak sizden bu noktada "sizin" bir ispat belirtmeniz gerekir, Yanlış anlamayın ama ben burada neyi kaçırıyorum anlamadım?

Merhaba Uğur bey, öncelikle ellerinize ve emeğinize sağlık. Benim uzunca örneğinizde görebildiğim kadarı ile uygulamanın ana(main) thread'i haricindeki başka bir thread şu anda ilgili instance'ı oluşturamıyor. Çünkü oluşturma kodunun içine ana thread kontrolü koymuşsunuz. Aslında siz, ilgili sınıfa erişimleri, sınıfın dışında organize etmeye çalışmış ve sınıfı bu şekilde korumaya çalışmışsınız. Ancak asıl beklenen, sınıfın kendi kendisini koruyabilmesidir. Çünkü programlama ortamında, ilgili instance oluşturan metodun nereden ve ne zaman çağrılacağı meçhuldür. Bu bağlamda, tüm koruma mekanizmalarını ilgili sınıfın intance oluşturan metodunun içinde yapmak; size yönetilmesi çok daha kolay bir sınıf verecektir.

 Maalesef thread'lerle alakalı testler çoğu zaman yeterli olmamaktadır. Bir çok unsur bir çok şeyin yanlış gitmesine neden olabilir. Bir t anında çalışan çok fazla thread olması, yeterli ram olmaması, işletim sisteminin server ya da client olması, çok fazla öncelik seviyesi yüksek thread'in çalışıyor olması vb. nedenlerden ötürü thread güvenlikli yazılmayan kodların bilinmeyen ve beklenmeyen zamanlarda patlamak gibi kötü huyları olabilir.

 Bir kod bloğuna aynı anda birden fazla thread'in girebilmesi ve aynı kodu işletebilmesi durumu; karmaşanın başladığı noktadır. Hafızada bulunan nesne instance'ları ya da daha low level bir tabir ile, hafızadaki bazı adreslerin içeriklerinin değişmesi bir başka thread için ise içeriğin farklı olarak algılanması her zaman mümkündür.

 İşletim sistemi thread'leri belirli bir algoritmaya göre(round robin) schedule etmektedir. Dolayısı ile bir thread'in işleteceği kod bloğunun tamamlanması beklenmez. Herhangi bir zamanda thread zamanlanabilir. Yazdığımız kodları makina kodu(assembly) olarak düşünür isek anlaşılması daha kolay olabilir. Bir thread zamanlandığında, işletim sistemi çeşitli imkanlar ile o andaki CPU yazmaçlarının değerlerini ve CPU'nun instruction pointer(EIP)'nın nerede olduğunu bir yerde saklar(CONTEXT). Ardından thread uykuya dalar. Tâki, işletim sistemi uykuya dalan thread'i uyandırmaya karar verene dek. Thread uyandırılmadan önce ilgili thread'e ait olan tüm context memory'e yeniden okunur, CPU'nun Instruction Pointer'ı ayarlanır ve thread kaldığı yerden çalıştırılmaya devam edilir.

 İşletim sisteminin bu belirsiz zamanlama mekanizmasından ötürü, aynı kod bloklarını işleten thread'lerin senkronize edilebilmesi gerekir. Ya da kritik kod bloklarının atomic yapıda olması gerekir. Atomik kodlar işletim sistemi tarafından kesintiye uğratılamaz ve ilgili kod işini tamamlamadan thread zamanlanamaz. Atomic fonksiyonlar için InterlockedIncrement vb. fonksiyonlara bakılabilir.

 Yardımcı olabileceğim başka bir husus var ise, lütfen arkadaşlarım akıllarına takılanları sorsunlar. Bilgim ve imkanım dahilinde ise yanıtlamaktan memnuniyet duyarım.
Tuğrul hocam çok güzel açıklamış ayrıca zamanında yazdığı aşağıdaki (altın değerindeki) yazıları da (konuyla igili) keyifle okumuştum, size de tavsiye ederim.

http://www.tugrulhelvaci.com/?p=443
http://www.tugrulhelvaci.com/?p=528
http://www.tugrulhelvaci.com/?p=568
(10-10-2017, Saat: 10:05)Tuğrul HELVACI Adlı Kullanıcıdan Alıntı: [ -> ]
(09-10-2017, Saat: 16:28)edo Adlı Kullanıcıdan Alıntı: [ -> ]Thread içinden GetInstance metodu çağrıldığında birden fazla Instance oluşmaması için yani Pattern'in Thread Safety olarak kullanılabilmesi için böyle bir şeye gerek olduğunu hatırlatmak istemiştim.

Yazınız için teşekkürler bu arada, eminim faydalı olacaktır.

edo'nun da bahsettiği gibi Singleton kalıbına double check ve thread safety sağlanır ise istenilen amaç daha stabil elde edilebilir. Double check aynı kod bloğuna birden fazla thread'in girmesi durumunda ve bu thread'lerin zamanlanması durumunda etkili olur. Tek başına double check'de yetmez. Bu bağlamda;

  if not Assigned(AInstance) then
  begin
    EnterCriticalSection;

      if not Assigned(AInstance) then
        AInstance := TMyInstance.Create;

    LeaveCriticalSection;
  end;

  Result := AInstance;


gibi bir kod yazmamız gerekir. Merak eden arkadaşlar, "double check" araması yaparak nedenlerini detaylıca irdeleyebilirler.
Konuyu yeni okuma fırsatım oldu EnterCriticalSection ek olarak şu şekilde bir kullanımda mevcutmuş
  if not Assigned(FHelper) then
  begin
   System.MonitorEnter(Self);
   try
     if not Assigned(FHelper) then
       FHelper := THelper.Create();
   finally
     System.MonitorExit(Self);
   end;
 end;
System.MonitorEnter(Self,500);
gibi millisecond cinsinden obje kilitlemeside yapılabiliyor
Sayfalar: 1 2