Monitör vs kilit

C # 'da iş parçacığı güvenliği için Monitorsınıfın veya lockanahtar sözcüğün kullanılması ne zaman uygundur ?

DÜZENLEME: Şimdiye kadar verilen cevaplardan lock, Monitorsınıfa yapılan bir dizi çağrı için kısa bir el gibi görünüyor . Kilit çağrısı tam olarak ne içindir? Veya daha açık bir şekilde,

class LockVsMonitor
{
    private readonly object LockObject = new object();
    public void DoThreadSafeSomethingWithLock(Action action)
    {
        lock (LockObject)
        {
            action.Invoke();
        }
    }
    public void DoThreadSafeSomethingWithMonitor(Action action)
    {
        // What goes here ?
    }
}

Güncelleme

Hepinize yardımınız için teşekkür ederim: Sağladığınız bilgilerden bazılarının devamı olarak başka bir soru gönderdim. Bu alanda çok bilgili göründüğünüz için, bağlantıyı gönderdim: Kilitli istisnaları kilitlemek ve yönetmek için bu çözümde yanlış olan nedir?

Eric Lippert blogunda bundan bahsediyor: Kilitler ve istisnalar karışmaz

Eşdeğer kod, C # 4.0 ve önceki sürümler arasında farklılık gösterir.

C # 4.0'da:

bool lockWasTaken = false;
var temp = obj;
try
{
    Monitor.Enter(temp, ref lockWasTaken);
    { body }
}
finally
{
    if (lockWasTaken) Monitor.Exit(temp);
}

Monitor.EnterKilit alındığında bayrağı atomik olarak ayarlamaya dayanır .

Ve daha önce şuydu:

var temp = obj;
Monitor.Enter(temp);
try
{
   body
}
finally
{
    Monitor.Exit(temp);
}

Bu Monitor.Enter, ile try. Hata ayıklama kodunda bu koşulun ihlal edildiğini düşünüyorum çünkü derleyici aralarına bir NOP ekledi ve böylece bunlar arasında iş parçacığı kürtajı mümkün oldu.

locksadece + ve Monitor.Enterile kısayol . Yeterli olduğunda kilit ifadesini kullanın - TryEnter gibi bir şeye ihtiyacınız varsa, Monitörü kullanmanız gerekecektir.tryfinallyMonitor.Exit

Bir kilit ifadesi şuna eşdeğerdir:

Monitor.Enter(object);
try
{
   // Your code here...
}
finally
{
   Monitor.Exit(object);
}

Bununla birlikte, Monitor'ün ayrıca karmaşık çoklu okuma durumlarında genellikle yararlı olan Wait () ve Pulse () de yapabileceğini unutmayın .

Güncelleme

Ancak C # 4'te farklı şekilde uygulanır:

bool lockWasTaken = false;
var temp = obj;
try 
{
     Monitor.Enter(temp, ref lockWasTaken); 
     //your code
}
finally 
{ 
     if (lockWasTaken) 
             Monitor.Exit(temp); 
} 

Yorumlar ve bağlantılar için CodeInChaos'a teşekkürler

Monitordaha esnektir. Monitörü kullanmakla ilgili en sevdiğim durum, sıranızı beklemek istemediğinizde ve şunları atlamanızdır :

//already executing? forget it, lets move on
if(Monitor.TryEnter(_lockObject))
{
    //do stuff;
    Monitor.Exit(_lockObject);
}

Başkalarının dediği gibi lock, "eşdeğerdir"

Monitor.Enter(object);
try
{
   // Your code here...
}
finally
{
   Monitor.Exit(object);
}

Ancak meraktan lockdolayı, ona geçtiğiniz ilk referansı koruyacak ve değiştirirseniz atmayacaktır. Kilitli nesneyi değiştirmenin tavsiye edilmediğini ve bunu yapmak istemediğini biliyorum.

Ama yine bilim için bu gayet iyi çalışıyor:

var lockObject = "";
var tasks = new List<Task>();
for (var i = 0; i < 10; i++)
    tasks.Add(Task.Run(() =>
    {
        Thread.Sleep(250);
        lock (lockObject)
        {
            lockObject += "x";
        }
    }));
Task.WaitAll(tasks.ToArray());

... Ve bu değil:

var lockObject = "";
var tasks = new List<Task>();
for (var i = 0; i < 10; i++)
    tasks.Add(Task.Run(() =>
    {
        Thread.Sleep(250);
        Monitor.Enter(lockObject);
        try
        {
            lockObject += "x";
        }
        finally
        {
            Monitor.Exit(lockObject);
        }
    }));
Task.WaitAll(tasks.ToArray());

Hata:

70783sTUDIES.exe'de 'System.Threading.SynchronizationLockException' türünde bir istisna oluştu ancak kullanıcı kodunda işlenmedi

Ek bilgi: Nesne senkronizasyon yöntemi, senkronize edilmemiş bir kod bloğundan çağrıldı.

Bunun nedeni , değişmez olduğu için değişmiş olana göre Monitor.Exit(lockObject);hareket edecek , o zaman onu senkronize edilmemiş bir kod bloğundan çağırıyorsunuz .. ama yine de. Bu sadece eğlenceli bir gerçek.lockObjectstrings

İkisi de aynı şey. kilit c keskin anahtar kelimedir ve Monitor sınıfını kullanın.

http://msdn.microsoft.com/en-us/library/ms173179(v=vs.80).aspx

Monitörün kilidi ve temel davranışı (giriş + çıkış) aşağı yukarı aynıdır, ancak monitörün size daha fazla senkronizasyon olanağı sağlayan daha fazla seçeneği vardır.

Kilit bir kısayoldur ve temel kullanım seçeneğidir.

Daha fazla kontrole ihtiyacınız varsa, monitör daha iyi bir seçenektir. Gelişmiş kullanımlar (bariyerler, semaforlar vb.) İçin Wait, TryEnter ve Pulse'u kullanabilirsiniz.

Lock Lock anahtar sözcüğü, bir iş parçacığının bir kerede bir kod parçasını yürütmesini sağlar.

lock (lockObject)

        {
        //   Body
        }

Lock anahtar sözcüğü, belirli bir nesne için karşılıklı dışlama kilidini elde ederek, bir ifadeyi çalıştırarak ve ardından kilidi serbest bırakarak bir ifade bloğunu kritik bir bölüm olarak işaretler.

Başka bir iş parçacığı kilitli bir kod girmeye çalışırsa, nesne serbest bırakılıncaya kadar bekleyecektir.

Monitor Monitor, statik bir sınıftır ve System.Threading ad alanına aittir.

Herhangi bir zamanda kritik bölüme yalnızca bir iş parçacığının girebilmesi için nesne üzerinde özel kilit sağlar.

C # 'da monitör ve kilit arasındaki fark

Kilit, Monitörün kısayoludur. Try ve nihayet girin. Kilit kolları deneyin ve sonunda dahili olarak engelleyin Kilit = İzle + en sonunda deneyin.

Eğer daha fazla kontrol kullanarak gelişmiş çoklu çözümler uygulamak istiyorsanız TryEnter() Wait(), Pulse()ve PulseAll()yöntemleri, ardından Monitör sınıfı sizin seçenektir.

C # Monitor.wait(): Bir iş parçacığı, diğer iş parçacıklarının bildirmesini beklemektedir.

Monitor.pulse(): Bir iş parçacığı başka bir iş parçacığına bildirir.

Monitor.pulseAll(): Bir iş parçacığı, bir süreç içindeki diğer tüm iş parçacıklarını bilgilendirir

Yukarıdaki tüm açıklamalara ek olarak, kilit bir C # ifadesidir, oysa Monitor System.Threading ad alanında bulunan bir .NET sınıfıdır.