volatile (C# Başvurusu)volatile (C# Reference)

volatile Anahtar sözcüğü gösteren bir alan, aynı anda yürütülen birden çok iş parçacığı tarafından değiştirilebilir.The volatile keyword indicates that a field might be modified by multiple threads that are executing at the same time. Derleyici, çalışma zamanı sistemi ve hatta donanım okuma ve bellek konumlara yazma işlemleri performans nedeniyle yeniden.The compiler, the runtime system, and even hardware may rearrange reads and writes to memory locations for performance reasons. Bildirilen alanları volatile bu iyileştirmeler tabi değildir.Fields that are declared volatile are not subject to these optimizations. Ekleme volatile değiştiricisi, tüm iş parçacıklarının bunlar hedeflenerek gerçekleştirildi sırada başka bir iş parçacığı tarafından gerçekleştirilen geçici yazma dikkate almasını sağlar.Adding the volatile modifier ensures that all threads will observe volatile writes performed by any other thread in the order in which they were performed. Bir tek toplam geçici yazma olarak görülen yürütme tüm iş parçacıklarından sıralama garantisi yoktur.There is no guarantee of a single total ordering of volatile writes as seen from all threads of execution.

volatile Anahtar sözcüğü, bu tür alanlar için uygulanabilir:The volatile keyword can be applied to fields of these types:

  • Başvuru türleri.Reference types.
  • İşaretçi türleri (güvenli olmayan bir bağlamda).Pointer types (in an unsafe context). İşaretçi geçici olabilir, ancak işaret nesnesi dönüştürülemez unutmayın.Note that although the pointer itself can be volatile, the object that it points to cannot. Diğer bir deyişle, "işaretçisi geçici." bildiremezsiniz.In other words, you cannot declare a "pointer to volatile."
  • Basit türler gibi sbyte, byte, short, ushort, int, uint, char, float, ve bool.Simple types such as sbyte, byte, short, ushort, int, uint, char, float, and bool.
  • Bir enum aşağıdaki temel türlerinden birini türüyle: byte, sbyte, short, ushort, int, veya uint.An enum type with one of the following base types: byte, sbyte, short, ushort, int, or uint.
  • Başvuru türleri olarak bilinen genel tür parametreleri.Generic type parameters known to be reference types.
  • IntPtr ve UIntPtr.IntPtr and UIntPtr.

Diğer türleri dahil olmak üzere, double ve long, işaretlenemiyor volatile çünkü okuma ve yazma işlemleri bu türlerin alanları atomik olmasını garanti edilemez.Other types, including double and long, cannot be marked volatile because reads and writes to fields of those types cannot be guaranteed to be atomic. Bu tür alanlar çok iş parçacıklı erişimi korumak için kullanmak Interlocked sınıf üyeleri veya erişim kullanarak koruma lock deyimi.To protect multi-threaded access to those types of fields, use the Interlocked class members or protect access using the lock statement.

volatile Anahtar sözcüğü yalnızca alanlarına uygulanabilir bir class veya struct.The volatile keyword can only be applied to fields of a class or struct. Yerel değişkenler bildirilemez volatile.Local variables cannot be declared volatile.

ÖrnekExample

Aşağıdaki örnek, bir ortak alan değişken olarak bildirmek gösterilmektedir volatile.The following example shows how to declare a public field variable as volatile.

class VolatileTest
{
    public volatile int sharedStorage;

    public void Test(int _i)
    {
        sharedStorage = _i;
    }
}

Aşağıdaki örnek nasıl yardımcı veya çalışan iş parçacığı oluşturulabilir ve birincil iş parçacığının ile paralel işleme gerçekleştirmek için kullanılan gösterir.The following example demonstrates how an auxiliary or worker thread can be created and used to perform processing in parallel with that of the primary thread. Daha fazla bilgi için ilgili çoklu iş parçacığı bakın yönetilen iş parçacığı.For more information about multithreading, see Managed Threading.

public class Worker
{
    // This method is called when the thread is started.
    public void DoWork()
    {
        bool work = false;
        while (!_shouldStop)
        {
            work = !work; // simulate some work
        }
        Console.WriteLine("Worker thread: terminating gracefully.");
    }
    public void RequestStop()
    {
        _shouldStop = true;
    }
    // Keyword volatile is used as a hint to the compiler that this data
    // member is accessed by multiple threads.
    private volatile bool _shouldStop;
}

public class WorkerThreadExample
{
    public static void Main()
    {
        // Create the worker thread object. This does not start the thread.
        Worker workerObject = new Worker();
        Thread workerThread = new Thread(workerObject.DoWork);

        // Start the worker thread.
        workerThread.Start();
        Console.WriteLine("Main thread: starting worker thread...");

        // Loop until the worker thread activates.
        while (!workerThread.IsAlive)
            ;

        // Put the main thread to sleep for 500 milliseconds to
        // allow the worker thread to do some work.
        Thread.Sleep(500);

        // Request that the worker thread stop itself.
        workerObject.RequestStop();

        // Use the Thread.Join method to block the current thread 
        // until the object's thread terminates.
        workerThread.Join();
        Console.WriteLine("Main thread: worker thread has terminated.");
    }
    // Sample output:
    // Main thread: starting worker thread...
    // Worker thread: terminating gracefully.
    // Main thread: worker thread has terminated.
}

İle volatile bildirimi için eklenen değiştiricisi _shouldStop yerde, her zaman aynı sonuçları (yukarıdaki kodda gösterildiği alıntı benzer) elde edersiniz.With the volatile modifier added to the declaration of _shouldStop in place, you'll always get the same results (similar to the excerpt shown in the preceding code). Ancak, bu değiştirici olmadan _shouldStop üyesi, davranıştır tahmin edilemez.However, without that modifier on the _shouldStop member, the behavior is unpredictable. DoWork Yöntemi eski verilerin okunmasını kaynaklanan üye erişimi iyileştirin.The DoWork method may optimize the member access, resulting in reading stale data. Çok iş parçacıklı programlama yapısı nedeniyle eski okuma sayısını tahmin edilemez.Because of the nature of multi-threaded programming, the number of stale reads is unpredictable. Programın farklı çalışmalarında biraz farklı sonuçlar oluşturur.Different runs of the program will produce somewhat different results.

C# dili belirtimiC# language specification

Daha fazla bilgi edinmek için, bkz. C# Dil Belirtimi.For more information, see the C# Language Specification. Dil belirtimi, C# sözdizimi ve kullanımı için kesin bir kaynaktır.The language specification is the definitive source for C# syntax and usage.

Ayrıca bkz.See also