System.Threading.Monitor sınıfı

Bu makale, bu API'nin başvuru belgelerine ek açıklamalar sağlar.

Monitor sınıfı, , Monitor.TryEnterve Monitor.Exit yöntemlerini çağırarak belirli bir nesne üzerinde kilit alıp serbest bırakarak kodun Monitor.Enterbir bölgesine erişimi eşitlemenize olanak tanır. Nesne kilitleri, genellikle kritik bölüm olarak adlandırılan bir kod bloğuna erişimi kısıtlama olanağı sağlar. Bir iş parçacığı bir nesnenin kilidine sahip olsa da, başka hiçbir iş parçacığı bu kilidi edinemez. Sınıfını Monitor , diğer iş parçacığı kodu farklı bir kilitli nesne kullanarak yürütmediği sürece kilit sahibi tarafından yürütülen uygulama kodunun bir bölümüne başka bir iş parçacığının erişmesine izin verilmediğinden emin olmak için de kullanabilirsiniz. İzleyici sınıfı iş parçacığı benzitesine sahip olduğundan, kilit alan iş parçacığının Monitor.Exit yöntemini çağırarak kilidi serbest bırakması gerekir.

Genel bakış

Monitor aşağıdaki özelliklere sahiptir:

• İsteğe bağlı bir nesneyle ilişkilendirilir.
• İlişkisizdir, yani doğrudan herhangi bir bağlamdan çağrılabilir.
• Sınıfın Monitor bir örneği oluşturulamaz; sınıfın yöntemlerinin Monitor tümü statiktir. Her yöntem, kritik bölüme erişimi denetleyen eşitlenmiş nesneye geçirilir.

Aşağıdaki tabloda, eşitlenmiş nesnelere erişen iş parçacıkları tarafından gerçekleştirilebilecek eylemler açıklanmaktadır:

ve TryEnter yöntemleri için Enter iki aşırı yükleme kümesi vardır. Bir aşırı yükleme kümesi, kilit alınırken bir özel durum oluştuğunda bile atomik olarak ayarlanmış bir ref (C#'de) veya ByRef (Visual Basic'te) Boolean parametresine true sahiptir. Kilidin koruduğu kaynaklar tutarlı bir durumda olmasa bile kilidin her durumda serbest bırakılması kritikse bu aşırı yüklemeleri kullanın.

Lock nesnesi

İzleyici sınıfı, kritik bölüme erişimi denetleyen bir nesne üzerinde çalışan (Shared Visual Basic'te) yöntemlerden oluşur static . Eşitlenen her nesne için aşağıdaki bilgiler korunur:

• Şu anda kilidi tutan iş parçacığına başvuru.
• Kilidi almaya hazır iş parçacıklarını içeren hazır kuyruğa başvuru.
• Kilitli nesnenin durumundaki bir değişikliğin bildirimini bekleyen iş parçacıklarını içeren bir bekleme kuyruğu başvurusu.

Monitor nesneleri (başvuru türleri) kilitler, değer türlerini kilitlemez. ve Exitöğesine Enter bir değer türü geçirebilirsiniz ancak her çağrı için ayrı olarak kutulanır. Her çağrı ayrı bir nesne oluşturduğundan, Enter hiçbir zaman engellemez ve koruduğu varsayılan kod gerçekten eşitlenmez. Buna ek olarak, geçirilen Exit nesne, geçirilen Enternesneden farklıdır, bu nedenle Monitor "Nesne eşitleme yöntemi zaman uyumsuz bir kod bloğundan çağrıldı" iletisiyle özel durum oluşturur SynchronizationLockException .

Aşağıdaki örnekte bu sorun gösterilmektedir. Her biri 250 milisaniye boyunca uyuyan on görev başlatır. Ardından her görev, nTasksgerçekten başlatılan ve yürütülen görev sayısını saymaya yönelik bir sayaç değişkenini güncelleştirir. nTasks Birden çok görev tarafından aynı anda güncelleştirilebilen genel bir değişken olduğundan, birden çok görev tarafından aynı anda değiştirilmesini korumak için bir izleyici kullanılır. Ancak, örnekteki çıktıda gösterildiği gibi, görevlerin her biri bir SynchronizationLockException özel durum oluşturur.

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

public class Example1
{
    public static void Main()
    {
        int nTasks = 0;
        List<Task> tasks = new List<Task>();

        try
        {
            for (int ctr = 0; ctr < 10; ctr++)
                tasks.Add(Task.Run(() =>
                { // Instead of doing some work, just sleep.
                    Thread.Sleep(250);
                    // Increment the number of tasks.
                    Monitor.Enter(nTasks);
                    try
                    {
                        nTasks += 1;
                    }
                    finally
                    {
                        Monitor.Exit(nTasks);
                    }
                }));
            Task.WaitAll(tasks.ToArray());
            Console.WriteLine("{0} tasks started and executed.", nTasks);
        }
        catch (AggregateException e)
        {
            String msg = String.Empty;
            foreach (var ie in e.InnerExceptions)
            {
                Console.WriteLine("{0}", ie.GetType().Name);
                if (!msg.Contains(ie.Message))
                    msg += ie.Message + Environment.NewLine;
            }
            Console.WriteLine("\nException Message(s):");
            Console.WriteLine(msg);
        }
    }
}
// The example displays the following output:
//    SynchronizationLockException
//    SynchronizationLockException
//    SynchronizationLockException
//    SynchronizationLockException
//    SynchronizationLockException
//    SynchronizationLockException
//    SynchronizationLockException
//    SynchronizationLockException
//    SynchronizationLockException
//    SynchronizationLockException
//
//    Exception Message(s):
//    Object synchronization method was called from an unsynchronized block of code.

Imports System.Collections.Generic
Imports System.Threading
Imports System.Threading.Tasks

Module Example3
    Public Sub Main()
        Dim nTasks As Integer = 0
        Dim tasks As New List(Of Task)()

        Try
            For ctr As Integer = 0 To 9
                tasks.Add(Task.Run(Sub()
                                       ' Instead of doing some work, just sleep.
                                       Thread.Sleep(250)
                                       ' Increment the number of tasks.
                                       Monitor.Enter(nTasks)
                                       Try
                                           nTasks += 1
                                       Finally
                                           Monitor.Exit(nTasks)
                                       End Try
                                   End Sub))
            Next
            Task.WaitAll(tasks.ToArray())
            Console.WriteLine("{0} tasks started and executed.", nTasks)
        Catch e As AggregateException
            Dim msg As String = String.Empty
            For Each ie In e.InnerExceptions
                Console.WriteLine("{0}", ie.GetType().Name)
                If Not msg.Contains(ie.Message) Then
                    msg += ie.Message + Environment.NewLine
                End If
            Next
            Console.WriteLine(vbCrLf + "Exception Message(s):")
            Console.WriteLine(msg)
        End Try
    End Sub
End Module
' The example displays the following output:
'    SynchronizationLockException
'    SynchronizationLockException
'    SynchronizationLockException
'    SynchronizationLockException
'    SynchronizationLockException
'    SynchronizationLockException
'    SynchronizationLockException
'    SynchronizationLockException
'    SynchronizationLockException
'    SynchronizationLockException
'
'    Exception Message(s):
'    Object synchronization method was called from an unsynchronized block of code.

Değişken, her görevdeki nTasks yönteme yapılan çağrıdan önce kutulandığından Monitor.Enter her görev bir SynchronizationLockException özel durum oluşturur. Başka bir deyişle, her yöntem çağrısı diğerlerinden bağımsız ayrı bir değişken geçirilir. nTasks yöntemine yapılan çağrıda Monitor.Exit yeniden kutulanır. Bir kez daha bu, birbirinden bağımsız nTaskson yeni kutulanmış değişken ve yöntemi çağrısında Monitor.Enter oluşturulan on kutulanmış değişken oluşturur. Özel durum oluşturulur, çünkü kodumuz daha önce kilitlenmemiş yeni oluşturulan bir değişkende kilit bırakmaya çalışır.

Aşağıdaki örnekte gösterildiği gibi ve Exitçağırmadan Enter önce bir değer türü değişkeni kutulayabilir ve aynı kutulanmış nesneyi her iki yönteme de geçirebilirsiniz, ancak bunu yapmanın bir avantajı yoktur. Kutulanmamış değişkendeki değişiklikler kutulanmış kopyaya yansıtılmaz ve kutulanmış kopyanın değerini değiştirmenin hiçbir yolu yoktur.

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

public class Example
{
   public static void Main()
   {

      int nTasks = 0;
      object o = nTasks;
      List<Task> tasks = new List<Task>();

      try {
         for (int ctr = 0; ctr < 10; ctr++)
            tasks.Add(Task.Run( () => { // Instead of doing some work, just sleep.
                                        Thread.Sleep(250);
                                        // Increment the number of tasks.
                                        Monitor.Enter(o);
                                        try {
                                           nTasks++;
                                        }
                                        finally {
                                           Monitor.Exit(o);
                                        }
                                      } ));
         Task.WaitAll(tasks.ToArray());
         Console.WriteLine("{0} tasks started and executed.", nTasks);
      }
      catch (AggregateException e) {
         String msg = String.Empty;
         foreach (var ie in e.InnerExceptions) {
            Console.WriteLine("{0}", ie.GetType().Name);
            if (! msg.Contains(ie.Message))
               msg += ie.Message + Environment.NewLine;
         }
         Console.WriteLine("\nException Message(s):");
         Console.WriteLine(msg);
      }
   }
}
// The example displays the following output:
//        10 tasks started and executed.

Imports System.Collections.Generic
Imports System.Threading
Imports System.Threading.Tasks

Module Example2
    Public Sub Main()
        Dim nTasks As Integer = 0
        Dim o As Object = nTasks
        Dim tasks As New List(Of Task)()

        Try
            For ctr As Integer = 0 To 9
                tasks.Add(Task.Run(Sub()
                                       ' Instead of doing some work, just sleep.
                                       Thread.Sleep(250)
                                       ' Increment the number of tasks.
                                       Monitor.Enter(o)
                                       Try
                                           nTasks += 1
                                       Finally
                                           Monitor.Exit(o)
                                       End Try
                                   End Sub))
            Next
            Task.WaitAll(tasks.ToArray())
            Console.WriteLine("{0} tasks started and executed.", nTasks)
        Catch e As AggregateException
            Dim msg As String = String.Empty
            For Each ie In e.InnerExceptions
                Console.WriteLine("{0}", ie.GetType().Name)
                If Not msg.Contains(ie.Message) Then
                    msg += ie.Message + Environment.NewLine
                End If
            Next
            Console.WriteLine(vbCrLf + "Exception Message(s):")
            Console.WriteLine(msg)
        End Try
    End Sub
End Module
' The example displays the following output:
'       10 tasks started and executed.

Eşitlenecek nesneyi seçerken, yalnızca özel veya iç nesnelere kilitlemelisiniz. İlişkili olmayan kod farklı amaçlarla kilitlenmek üzere aynı nesneleri seçebileceğinden, dış nesnelere kilitlenmeye neden olabilir.

Kilit için kullanılan nesne öğesinden MarshalByRefObjecttüretilirse, birden çok uygulama etki alanında bulunan bir nesne üzerinde eşitleme yapabileceğinizi unutmayın.

Kritik bölüm

Kritik bir bölümün başlangıcını Enter ve sonunu işaretlemek için ve Exit yöntemlerini kullanın.

Kritik bölüm bitişik yönergeler kümesiyse, yöntemi tarafından Enter alınan kilit, kapalı kodu kilitli nesneyle yalnızca tek bir iş parçacığının yürütebileceğini garanti eder. Bu durumda, bu kodu bir try bloğa yerleştirmenizi ve yöntemine çağrıyı Exit bir finally blokta yerleştirmenizi öneririz. Bu, bir özel durum oluştuğunda bile kilidin serbest bırakılmasını sağlar. Aşağıdaki kod parçası bu düzeni gösterir.

// Define the lock object.
var obj = new Object();

// Define the critical section.
Monitor.Enter(obj);
try
{
    // Code to execute one thread at a time.
}
// catch blocks go here.
finally
{
    Monitor.Exit(obj);
}

' Define the lock object.
Dim obj As New Object()

' Define the critical section.
Monitor.Enter(obj)
Try
    ' Code to execute one thread at a time.

    ' catch blocks go here.
Finally
    Monitor.Exit(obj)
End Try

Bu tesis genellikle bir sınıfın statik veya örnek yöntemine erişimi eşitlemek için kullanılır.

Kritik bir bölüm yöntemin tamamına yayılmışsa, kilitleme tesisi yöntemine yerleştirilip System.Runtime.CompilerServices.MethodImplAttribute oluşturucusunda System.Runtime.CompilerServices.MethodImplAttributedeğeri belirtilerek Synchronized gerçekleştirilebilir. Bu özniteliği kullandığınızda ve EnterExit yöntemi çağrıları gerekli değildir. Aşağıdaki kod parçası bu düzeni gösterir:

[MethodImplAttribute(MethodImplOptions.Synchronized)]
void MethodToLock()
{
    // Method implementation.
}

<MethodImplAttribute(MethodImplOptions.Synchronized)>
Sub MethodToLock()
    ' Method implementation.
End Sub

özniteliğinin geçerli iş parçacığının yöntem dönene kadar kilidi tutmasına neden olduğunu unutmayın; kilit daha önce serbest bırakılabilirse, özniteliği yerine yönteminin Monitor içindeki sınıfını, C# lock deyimini veya Visual Basic SyncLock deyimini kullanın.

Belirli bir nesneyi kilitleyip serbest bırakan ve Exit deyimlerinin üye veya sınıf sınırlarını ya da her ikisini birden aşması mümkün Enter olsa da, bu uygulama önerilmez.

Pulse, PulseAll ve Wait

Bir iş parçacığı kilidin sahibi olduktan ve kilidin koruduğu kritik bölüme girdikten sonra , Monitor.Pulseve Monitor.PulseAll yöntemlerini çağırabilirMonitor.Wait.

Kilidi tutan iş parçacığı çağırdığında Wait, kilit serbest bırakılır ve iş parçacığı eşitlenen nesnenin bekleme kuyruğuna eklenir. Hazır sıradaki ilk iş parçacığı varsa kilidi alır ve kritik bölüme girer. çağrılan Wait iş parçacığı, veya Monitor.PulseAll yöntemi kilidi tutan iş parçacığı tarafından çağrıldığında Monitor.Pulse bekleme kuyruğundan hazır kuyruğa taşınır (taşınabilmesi için, iş parçacığı bekleme kuyruğunun başında olmalıdır). çağıran Wait iş parçacığı kilidi yeniden alırsa yöntemi döndürür.

Kilidi tutan iş parçacığı çağırdığında Pulse, bekleme kuyruğunun başındaki iş parçacığı hazır kuyruğa taşınır. yöntemine yapılan PulseAll çağrı, bekleyen kuyruktan hazır kuyruğa tüm iş parçacıklarını taşır.

İzleyiciler ve bekleme tutamaçları

Sınıfın WaitHandle ve nesnelerin kullanımı Monitor arasındaki ayrımı not etmek önemlidir.

• Sınıfı Monitor tamamen yönetilir, tamamen taşınabilir ve işletim sistemi kaynak gereksinimleri açısından daha verimli olabilir.
• WaitHandle nesneler işletim sistemi tarafından beklenebilen nesneleri temsil eder, yönetilen ve yönetilmeyen kod arasında eşitleme yapmak için yararlıdır ve aynı anda birçok nesnede bekleme yeteneği gibi bazı gelişmiş işletim sistemi özelliklerini kullanıma sunar.

Örnekler

Aşağıdaki örnek, sınıfı tarafından Monitor temsil edilen rastgele bir sayı oluşturucunun tek bir örneğine erişimi eşitlemek için sınıfını Random kullanır. Örnek, her biri bir iş parçacığı havuzu iş parçacığında zaman uyumsuz olarak yürütülen on görev oluşturur. Her görev 10.000 rastgele sayı oluşturur, bunların ortalamasını hesaplar ve oluşturulan rastgele sayı sayısının ve toplamlarının çalışan toplamını koruyan iki yordam düzeyinde değişkeni güncelleştirir. Tüm görevler yürütüldükten sonra, bu iki değer genel ortalamayı hesaplamak için kullanılır.

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

public class Example2
{
    public static void Main()
    {
        List<Task> tasks = new List<Task>();
        Random rnd = new Random();
        long total = 0;
        int n = 0;

        for (int taskCtr = 0; taskCtr < 10; taskCtr++)
            tasks.Add(Task.Run(() =>
            {
                int[] values = new int[10000];
                int taskTotal = 0;
                int taskN = 0;
                int ctr = 0;
                Monitor.Enter(rnd);
                // Generate 10,000 random integers
                for (ctr = 0; ctr < 10000; ctr++)
                    values[ctr] = rnd.Next(0, 1001);
                Monitor.Exit(rnd);
                taskN = ctr;
                foreach (var value in values)
                    taskTotal += value;

                Console.WriteLine("Mean for task {0,2}: {1:N2} (N={2:N0})",
                                  Task.CurrentId, (taskTotal * 1.0) / taskN,
                                  taskN);
                Interlocked.Add(ref n, taskN);
                Interlocked.Add(ref total, taskTotal);
            }));
        try
        {
            Task.WaitAll(tasks.ToArray());
            Console.WriteLine("\nMean for all tasks: {0:N2} (N={1:N0})",
                              (total * 1.0) / n, n);
        }
        catch (AggregateException e)
        {
            foreach (var ie in e.InnerExceptions)
                Console.WriteLine("{0}: {1}", ie.GetType().Name, ie.Message);
        }
    }
}
// The example displays output like the following:
//       Mean for task  1: 499.04 (N=10,000)
//       Mean for task  2: 500.42 (N=10,000)
//       Mean for task  3: 499.65 (N=10,000)
//       Mean for task  8: 502.59 (N=10,000)
//       Mean for task  5: 502.75 (N=10,000)
//       Mean for task  4: 494.88 (N=10,000)
//       Mean for task  7: 499.22 (N=10,000)
//       Mean for task 10: 496.45 (N=10,000)
//       Mean for task  6: 499.75 (N=10,000)
//       Mean for task  9: 502.79 (N=10,000)
//
//       Mean for all tasks: 499.75 (N=100,000)

Imports System.Collections.Generic
Imports System.Threading
Imports System.Threading.Tasks

Module Example4
    Public Sub Main()
        Dim tasks As New List(Of Task)()
        Dim rnd As New Random()
        Dim total As Long = 0
        Dim n As Integer = 0

        For taskCtr As Integer = 0 To 9
            tasks.Add(Task.Run(Sub()
                                   Dim values(9999) As Integer
                                   Dim taskTotal As Integer = 0
                                   Dim taskN As Integer = 0
                                   Dim ctr As Integer = 0
                                   Monitor.Enter(rnd)
                                   ' Generate 10,000 random integers.
                                   For ctr = 0 To 9999
                                       values(ctr) = rnd.Next(0, 1001)
                                   Next
                                   Monitor.Exit(rnd)
                                   taskN = ctr
                                   For Each value In values
                                       taskTotal += value
                                   Next

                                   Console.WriteLine("Mean for task {0,2}: {1:N2} (N={2:N0})",
                                                  Task.CurrentId, taskTotal / taskN,
                                                  taskN)
                                   Interlocked.Add(n, taskN)
                                   Interlocked.Add(total, taskTotal)
                               End Sub))
        Next

        Try
            Task.WaitAll(tasks.ToArray())
            Console.WriteLine()
            Console.WriteLine("Mean for all tasks: {0:N2} (N={1:N0})",
                           (total * 1.0) / n, n)
        Catch e As AggregateException
            For Each ie In e.InnerExceptions
                Console.WriteLine("{0}: {1}", ie.GetType().Name, ie.Message)
            Next
        End Try
    End Sub
End Module
' The example displays output like the following:
'       Mean for task  1: 499.04 (N=10,000)
'       Mean for task  2: 500.42 (N=10,000)
'       Mean for task  3: 499.65 (N=10,000)
'       Mean for task  8: 502.59 (N=10,000)
'       Mean for task  5: 502.75 (N=10,000)
'       Mean for task  4: 494.88 (N=10,000)
'       Mean for task  7: 499.22 (N=10,000)
'       Mean for task 10: 496.45 (N=10,000)
'       Mean for task  6: 499.75 (N=10,000)
'       Mean for task  9: 502.79 (N=10,000)
'
'       Mean for all tasks: 499.75 (N=100,000)

İş parçacığı havuzu iş parçacığında çalışan herhangi bir görevden erişilebildiği için değişkenlere total erişim ve n ayrıca eşitlenmesi gerekir. Interlocked.Add yöntemi bu amaç için kullanılır.

Aşağıdaki örnekte sınıfın (veya SyncLock dil yapısıyla lock uygulanır), sınıfın ve sınıfın Interlocked birleştirilmiş kullanımı Monitor gösterilmektedirAutoResetEvent. Bir kaynağa eşitlenmiş ve eşitlenmemiş erişim sağlayan iki internal (C#içinde) veya Friend (Visual Basic'te) ve UnSyncResourcesınıflarını SyncResource tanımlar. Örnekte eşitlenmiş ve eşitlenmemiş erişim arasındaki farkın gösterildiğinden emin olmak için (her yöntem çağrısı hızla tamamlanırsa bu durum söz konusu olabilir), yöntem rastgele bir gecikme içerir: özelliği eşit olan Thread.ManagedThreadId iş parçacıkları için yöntem, 2.000 milisaniyelik bir gecikmeye neden olmaya çağırır Thread.Sleep . SyncResource Sınıfı genel olmadığından, istemci kodunun hiçbiri eşitlenen kaynak üzerinde kilit almaz; iç sınıfın kendisi kilidi alır. Bu, kötü amaçlı kodun ortak bir nesneye kilitlenmesini önler.

using System;
using System.Threading;

internal class SyncResource
{
    // Use a monitor to enforce synchronization.
    public void Access()
    {
        lock(this) {
            Console.WriteLine("Starting synchronized resource access on thread #{0}",
                              Thread.CurrentThread.ManagedThreadId);
            if (Thread.CurrentThread.ManagedThreadId % 2 == 0)
                Thread.Sleep(2000);

            Thread.Sleep(200);
            Console.WriteLine("Stopping synchronized resource access on thread #{0}",
                              Thread.CurrentThread.ManagedThreadId);
        }
    }
}

internal class UnSyncResource
{
    // Do not enforce synchronization.
    public void Access()
    {
        Console.WriteLine("Starting unsynchronized resource access on Thread #{0}",
                          Thread.CurrentThread.ManagedThreadId);
        if (Thread.CurrentThread.ManagedThreadId % 2 == 0)
            Thread.Sleep(2000);

        Thread.Sleep(200);
        Console.WriteLine("Stopping unsynchronized resource access on thread #{0}",
                          Thread.CurrentThread.ManagedThreadId);
    }
}

public class App
{
    private static int numOps;
    private static AutoResetEvent opsAreDone = new AutoResetEvent(false);
    private static SyncResource SyncRes = new SyncResource();
    private static UnSyncResource UnSyncRes = new UnSyncResource();

   public static void Main()
   {
        // Set the number of synchronized calls.
        numOps = 5;
        for (int ctr = 0; ctr <= 4; ctr++)
            ThreadPool.QueueUserWorkItem(new WaitCallback(SyncUpdateResource));

        // Wait until this WaitHandle is signaled.
        opsAreDone.WaitOne();
        Console.WriteLine("\t\nAll synchronized operations have completed.\n");

        // Reset the count for unsynchronized calls.
        numOps = 5;
        for (int ctr = 0; ctr <= 4; ctr++)
            ThreadPool.QueueUserWorkItem(new WaitCallback(UnSyncUpdateResource));

        // Wait until this WaitHandle is signaled.
        opsAreDone.WaitOne();
        Console.WriteLine("\t\nAll unsynchronized thread operations have completed.\n");
   }

    static void SyncUpdateResource(Object state)
    {
        // Call the internal synchronized method.
        SyncRes.Access();

        // Ensure that only one thread can decrement the counter at a time.
        if (Interlocked.Decrement(ref numOps) == 0)
            // Announce to Main that in fact all thread calls are done.
            opsAreDone.Set();
    }

    static void UnSyncUpdateResource(Object state)
    {
        // Call the unsynchronized method.
        UnSyncRes.Access();

        // Ensure that only one thread can decrement the counter at a time.
        if (Interlocked.Decrement(ref numOps) == 0)
            // Announce to Main that in fact all thread calls are done.
            opsAreDone.Set();
    }
}
// The example displays output like the following:
//    Starting synchronized resource access on thread #6
//    Stopping synchronized resource access on thread #6
//    Starting synchronized resource access on thread #7
//    Stopping synchronized resource access on thread #7
//    Starting synchronized resource access on thread #3
//    Stopping synchronized resource access on thread #3
//    Starting synchronized resource access on thread #4
//    Stopping synchronized resource access on thread #4
//    Starting synchronized resource access on thread #5
//    Stopping synchronized resource access on thread #5
//
//    All synchronized operations have completed.
//
//    Starting unsynchronized resource access on Thread #7
//    Starting unsynchronized resource access on Thread #9
//    Starting unsynchronized resource access on Thread #10
//    Starting unsynchronized resource access on Thread #6
//    Starting unsynchronized resource access on Thread #3
//    Stopping unsynchronized resource access on thread #7
//    Stopping unsynchronized resource access on thread #9
//    Stopping unsynchronized resource access on thread #3
//    Stopping unsynchronized resource access on thread #10
//    Stopping unsynchronized resource access on thread #6
//
//    All unsynchronized thread operations have completed.

Imports System.Threading

Friend Class SyncResource
    ' Use a monitor to enforce synchronization.
    Public Sub Access()
        SyncLock Me
            Console.WriteLine("Starting synchronized resource access on thread #{0}",
                              Thread.CurrentThread.ManagedThreadId)
            If Thread.CurrentThread.ManagedThreadId Mod 2 = 0 Then
                Thread.Sleep(2000)
            End If
            Thread.Sleep(200)
            Console.WriteLine("Stopping synchronized resource access on thread #{0}",
                              Thread.CurrentThread.ManagedThreadId)
        End SyncLock
    End Sub
End Class

Friend Class UnSyncResource
    ' Do not enforce synchronization.
    Public Sub Access()
        Console.WriteLine("Starting unsynchronized resource access on Thread #{0}",
                          Thread.CurrentThread.ManagedThreadId)
        If Thread.CurrentThread.ManagedThreadId Mod 2 = 0 Then
            Thread.Sleep(2000)
        End If
        Thread.Sleep(200)
        Console.WriteLine("Stopping unsynchronized resource access on thread #{0}",
                          Thread.CurrentThread.ManagedThreadId)
    End Sub
End Class

Public Module App
    Private numOps As Integer
    Private opsAreDone As New AutoResetEvent(False)
    Private SyncRes As New SyncResource()
    Private UnSyncRes As New UnSyncResource()

    Public Sub Main()
        ' Set the number of synchronized calls.
        numOps = 5
        For ctr As Integer = 0 To 4
            ThreadPool.QueueUserWorkItem(New WaitCallback(AddressOf SyncUpdateResource))
        Next
        ' Wait until this WaitHandle is signaled.
        opsAreDone.WaitOne()
        Console.WriteLine(vbTab + Environment.NewLine + "All synchronized operations have completed.")
        Console.WriteLine()

        numOps = 5
        ' Reset the count for unsynchronized calls.
        For ctr As Integer = 0 To 4
            ThreadPool.QueueUserWorkItem(New WaitCallback(AddressOf UnSyncUpdateResource))
        Next

        ' Wait until this WaitHandle is signaled.
        opsAreDone.WaitOne()
        Console.WriteLine(vbTab + Environment.NewLine + "All unsynchronized thread operations have completed.")
    End Sub

    Sub SyncUpdateResource()
        ' Call the internal synchronized method.
        SyncRes.Access()

        ' Ensure that only one thread can decrement the counter at a time.
        If Interlocked.Decrement(numOps) = 0 Then
            ' Announce to Main that in fact all thread calls are done.
            opsAreDone.Set()
        End If
    End Sub

    Sub UnSyncUpdateResource()
        ' Call the unsynchronized method.
        UnSyncRes.Access()

        ' Ensure that only one thread can decrement the counter at a time.
        If Interlocked.Decrement(numOps) = 0 Then
            ' Announce to Main that in fact all thread calls are done.
            opsAreDone.Set()
        End If
    End Sub
End Module
' The example displays output like the following:
'    Starting synchronized resource access on thread #6
'    Stopping synchronized resource access on thread #6
'    Starting synchronized resource access on thread #7
'    Stopping synchronized resource access on thread #7
'    Starting synchronized resource access on thread #3
'    Stopping synchronized resource access on thread #3
'    Starting synchronized resource access on thread #4
'    Stopping synchronized resource access on thread #4
'    Starting synchronized resource access on thread #5
'    Stopping synchronized resource access on thread #5
'
'    All synchronized operations have completed.
'
'    Starting unsynchronized resource access on Thread #7
'    Starting unsynchronized resource access on Thread #9
'    Starting unsynchronized resource access on Thread #10
'    Starting unsynchronized resource access on Thread #6
'    Starting unsynchronized resource access on Thread #3
'    Stopping unsynchronized resource access on thread #7
'    Stopping unsynchronized resource access on thread #9
'    Stopping unsynchronized resource access on thread #3
'    Stopping unsynchronized resource access on thread #10
'    Stopping unsynchronized resource access on thread #6
'
'    All unsynchronized thread operations have completed.

Örnek, numOpskaynağa erişmeye çalışacak iş parçacığı sayısını tanımlayan bir değişkeni tanımlar. Uygulama iş parçacığı eşitlenmiş ve eşitlenmemiş erişim için yöntemini beş kez çağırır ThreadPool.QueueUserWorkItem(WaitCallback) . yönteminde ThreadPool.QueueUserWorkItem(WaitCallback) tek bir parametre, parametre kabul eden ve değer döndürmez bir temsilci bulunur. Eşitlenmiş erişim için yöntemini çağırır SyncUpdateResource ; eşitlenmemiş erişim için yöntemini çağırır UnSyncUpdateResource . Her yöntem kümesi çağrılarından sonra, uygulama iş parçacığı AutoResetEvent.WaitOne yöntemini çağırarak örnek sinyal alınana kadar engellemesini AutoResetEvent sağlar.

Yöntemine yapılan SyncUpdateResource her çağrı iç SyncResource.Access yöntemi çağırır ve ardından sayacını azaltmaya numOps yönelik yöntemini çağırırInterlocked.Decrement. Interlocked.Decrement yöntemi sayacın azalmasını sağlamak için kullanılır, aksi takdirde ikinci bir iş parçacığının değere ilk iş parçacığının azalan değeri değişkende depolanmadan önce erişeceğinden emin olamazsınız. Son eşitlenen çalışan iş parçacığı, tüm eşitlenen iş parçacıklarının kaynağa erişmesinin tamamlandığını belirterek sayacı sıfıra düşürdüyse, SyncUpdateResource yöntemi yöntemini çağırır EventWaitHandle.Set ve bu yöntem ana iş parçacığının yürütmeye devam etmesi için sinyal gönderir.

Yöntemine yapılan UnSyncUpdateResource her çağrı iç UnSyncResource.Access yöntemi çağırır ve ardından sayacını azaltmaya numOps yönelik yöntemini çağırırInterlocked.Decrement. Bir kez daha, ilk iş parçacığının Interlocked.Decrement azalan değeri değişkenine atanmadan önce ikinci bir iş parçacığının değere erişmediğinden emin olmak için sayacı azaltma yöntemi kullanılır. Son eşitlenmemiş çalışan iş parçacığı sayacı sıfır olarak azalttığında ve artık eşitlenmemiş iş parçacıklarının kaynağa erişmesi gerekmediğini gösterirse, UnSyncUpdateResource yöntem yöntemini çağırır EventWaitHandle.Set ve bu da ana iş parçacığının yürütmeye devam etmesi için sinyal gönderir.

Örnekteki çıktıda gösterildiği gibi, eşitlenmiş erişim çağıran iş parçacığının başka bir iş parçacığına erişmeden önce korumalı kaynaktan çıkmasını sağlar; her iş parçacığı öncülünü bekler. Öte yandan, kilit olmadan, UnSyncResource.Access yöntem iş parçacıklarının ulaşıldığı sırayla çağrılır.