zoukankan      html  css  js  c++  java
  • When should the volatile keyword be used in C#?

    When should the volatile keyword be used in C#?

    I don't think there's a better person to answer this than Eric Lippert (emphasis in the original):

    In C#, "volatile" means not only "make sure that the compiler and the jitter do not perform any code reordering or register caching optimizations on this variable". It also means "tell the processors to do whatever it is they need to do to ensure that I am reading the latest value, even if that means halting other processors and making them synchronize main memory with their caches".

    Actually, that last bit is a lie. The true semantics of volatile reads and writes are considerably more complex than I've outlined here; in fact they do not actually guarantee that every processor stops what it is doing and updates caches to/from main memory. Rather, they provide weaker guarantees about how memory accesses before and after reads and writes may be observed to be ordered with respect to each other. Certain operations such as creating a new thread, entering a lock, or using one of the Interlocked family of methods introduce stronger guarantees about observation of ordering. If you want more details, read sections 3.10 and 10.5.3 of the C# 4.0 specification.

    Frankly, I discourage you from ever making a volatile field. Volatile fields are a sign that you are doing something downright crazy: you're attempting to read and write the same value on two different threads without putting a lock in place. Locks guarantee that memory read or modified inside the lock is observed to be consistent, locks guarantee that only one thread accesses a given chunk of memory at a time, and so on. The number of situations in which a lock is too slow is very small, and the probability that you are going to get the code wrong because you don't understand the exact memory model is very large. I don't attempt to write any low-lock code except for the most trivial usages of Interlocked operations. I leave the usage of "volatile" to real experts.

    For further reading see:

    volatile (C# Reference)

    The volatile keyword indicates that a field might be modified by multiple threads that are executing at the same time. The compiler, the runtime system, and even hardware may rearrange reads and writes to memory locations for performance reasons. Fields that are declared volatile are not subject to these optimizations. 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. There is no guarantee of a single total ordering of volatile writes as seen from all threads of execution.

    The volatile keyword can be applied to fields of these types:

    • Reference types.
    • Pointer types (in an unsafe context). Note that although the pointer itself can be volatile, the object that it points to cannot. In other words, you cannot declare a "pointer to volatile."
    • Simple types such as sbytebyteshortushortintuintcharfloat, and bool.
    • An enum type with one of the following base types: bytesbyteshortushortint, or uint.
    • Generic type parameters known to be reference types.
    • IntPtr and UIntPtr.

    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. To protect multi-threaded access to those types of fields, use the Interlocked class members or protect access using the lock statement.

    The volatile keyword can only be applied to fields of a class or struct. Local variables cannot be declared volatile.

    https://stackoverflow.com/questions/72275/when-should-the-volatile-keyword-be-used-in-c

  • 相关阅读:
    点击拖动,让物体旋转
    unity中让物体不能穿到另一个物体里面去
    XML一小节
    unity中摄像机的控制---调整摄像机,不让他摔倒
    Unity 制作游侠暂停
    unity使用 NGUI制作技能冷却效果的思路
    unity中设置贴图的透明
    C#中实现打开文件夹所在的位置
    Windows下的MongoDB的安装与配置
    Scrapy运行中常见网络相关错误
  • 原文地址:https://www.cnblogs.com/chucklu/p/13362793.html
Copyright © 2011-2022 走看看