C#易失域、锁的分享，多线程

C#多线程、易失域、锁的分享

一、多线程

　　windows系统是一个多线程的操作系统。一个程序至少有一个进程,一个进程至少有一个线程。进程是线程的容器，一个C#客户端程序开始于一个单独的线程，CLR(公共语言运行库)为该进程创建了一个线程，该线程称为主线程。例如当我们创建一个C#控制台程序，程序的入口是Main()函数，Main()函数是始于一个主线程的。它的功能主要 是产生新的线程和执行程序。

　　在软件中，如果有一种操作可以被多人同时调用，我们就可以创建多个线程同时处理，以提高任务执行效率。这时，操作就被分配到各个线程中分别执行。

在C#中我们可以使用Thread类和ThreadStart委托，他们都定义在System.Threading命名空间中。

　　ThreadStart委托类型用于定义在线程中的工作，就像我们在使用其他的委托类型一样，可以使用方法名来创建此委托类型对象，如“new ThreadStart(test)”

多线程优点： 
(1)多线程技术使程序的响应速度更快 ,因为用户界面可以在进行其它工作的同时一直处于活动状态; 
(2)多线程可以提高CPU的利用率，因为当一个线程处于等待状态的时候，CPU会去执行另外的线程; 
(3)占用大量处理时间的任务可以定期将处理器时间让给其它任务; 
(4)可以随时停止任务; 
(5)可以分别设置各个任务的优先级以优化性能。

多线程缺点： 
(1)等候使用共享资源时造成程序的运行速度变慢。这些共享资源主要是独占性的资源 ,如写文件等。 
(2)对线程进行管理要求额外的 CPU开销。线程的使用会给系统带来上下文切换的额外负担。当这种负担超过一定程度时,多线程的特点主要表现在其缺点上,比如用独立的线程来更新数组内每个元素。 
(3)线程的死锁。即较长时间的等待或资源竞争以及死锁等多线程症状。 
(4)对公有变量的同时读或写。当多个线程需要对公有变量进行写操作时,后一个线程往往会修改掉前一个线程存放的数据,从而使前一个线程的参数被修改;另外 ,当公用变量的读写操作是非原子性时,在不同的机器上,中断时间的不确定性,会导致数据在一个线程内的操作产生错误,从而产生莫名其妙的错误,而这种错误是程序员无法预知的。

线程生命周期

线程生命周期开始于 System.Threading.Thread 类的对象被创建时，结束于线程被终止或完成执行时。

下面列出了线程生命周期中的各种状态：

• • 未启动状态：当线程实例被创建但 Start 方法未被调用时的状况。
  • 就绪状态：当线程准备好运行并等待 CPU 周期时的状况。
  • 不可运行状态：下面的几种情况下线程是不可运行的：
    • 已经调用 Sleep 方法
    • 已经调用 Wait 方法
    • 通过 I/O 操作阻塞
  • 死亡状态：当线程已完成执行或已中止时的状况

Thread 类常用的属性和方法

　　

最简单的多线程例子，代码如下：

static void Main(string[] agrs)
        {
            ThreadStart threadWork = new ThreadStart(test);
            Thread t1 = new Thread(threadWork);
            t1.Name = "t1";
            Thread t2 = new Thread(threadWork);
            t2.Name = "t2";
            Thread t3 = new Thread(threadWork);
            t3.Name = "t3";
            //开始执行
            t1.Start();
            t2.Start();
            t3.Start();
            Console.ReadKey();
        }
        static public void  test(){
            Console.WriteLine("{0},hello,小菜鸟",Thread.CurrentThread.Name);
        }

使用多线程另一个重要的问题就是对于公共资源分配的控制，比如，火车的座位是有限的，在不同购票点买票时，就需要对座位资源进行合理分配；在电影院看电影也是这样的，座位只有那么多，我们不可能100个座位卖出200张票，这样是不可以的也是不应该的，那么接下来我们就要看看该如何解决这个问题。

二、易失域

对于类中的成员使用volatile修饰符，它就会被声明为易失域。对于易失域，在多线程环境中，每个线程中对此域的读取（易失读取，volatile read）和写入（易失写入，volatile write）操作都会观察其他线程中的操作，并进行操作的顺序执行，这样就保持易失域使用的一致性了。

volatile的作用是： 作为指令关键字，确保本条指令不会因编译器的优化而省略，且要求每次直接读值。多线程的程序，共同访问的内存当中，多个线程都可以操纵，从而无法判定何时这个变量会发生变化

可以这样简单理解：线程是并行的，但对volatile的访问是顺序排除的，避免出现脏值。

C#中volatile的用法

 

注：本文为个人学习摘录，原文地址：http://www.cnblogs.com/gjhjoy/p/3556709.html

恐怕比较一下volatile和synchronized的不同是最容易解释清楚的。volatile是变量修饰符，而synchronized则作用于一段代码或方法；看如下三句get代码：

1. int i1;              int geti1() {return i1;}
2. volatile int i2;  int geti2() {return i2;}
3. int i3;              synchronized int geti3() {return i3;}

　　geti1()得到存储在当前线程中i1的数值。多个线程有多个i1变量拷贝，而且这些i1之间可以互不相同。换句话说，另一个线程可能已经改 变了它线程内的i1值，而这个值可以和当前线程中的i1值不相同。事实上，Java有个思想叫“主”内存区域，这里存放了变量目前的“准确值”。每个线程 可以有它自己的变量拷贝，而这个变量拷贝值可以和“主”内存区域里存放的不同。因此实际上存在一种可能：“主”内存区域里的i1值是1，线程1里的i1值 是2，线程2里的i1值是3——这在线程1和线程2都改变了它们各自的i1值，而且这个改变还没来得及传递给“主”内存区域或其他线程时就会发生。
　 　而geti2()得到的是“主”内存区域的i2数值。用volatile修饰后的变量不允许有不同于“主”内存区域的变量拷贝。换句话说，一个变量经 volatile修饰后在所有线程中必须是同步的；任何线程中改变了它的值，所有其他线程立即获取到了相同的值。理所当然的，volatile修饰的变量 存取时比一般变量消耗的资源要多一点，因为线程有它自己的变量拷贝更为高效。
　　既然volatile关键字已经实现了线程间数据同步，又要 synchronized干什么呢？呵呵，它们之间有两点不同。首先，synchronized获得并释放监视器——如果两个线程使用了同一个对象锁，监 视器能强制保证代码块同时只被一个线程所执行——这是众所周知的事实。但是，synchronized也同步内存：事实上，synchronized在“ 主”内存区域同步整个线程的内存。因此，执行geti3()方法做了如下几步：
1. 线程请求获得监视this对象的对象锁（假设未被锁，否则线程等待直到锁释放）
2. 线程内存的数据被消除，从“主”内存区域中读入（Java虚拟机能优化此步。。。[后面的不知道怎么表达,汗]）
3. 代码块被执行
4. 对于变量的任何改变现在可以安全地写到“主”内存区域中（不过geti3()方法不会改变变量值）
5. 线程释放监视this对象的对象锁
　　因此volatile只是在线程内存和“主”内存间同步某个变量的值，而synchronized通过锁定和解锁某个监视器同步所有变量的值。显然synchronized要比volatile消耗更多资源。

更通俗的解释：

Volatile 字面的意思时易变的，不稳定的。在C#中也差不多可以这样理解。

编译器在优化代码时，可能会把经常用到的代码存在Cache里面，然后下一次调用就直接读取Cache而不是内存，这样就大大提高了效率。但是问题也随之而来了。

在多线程程序中，如果把一个变量放入Cache后，又有其他线程改变了变量的值，那么本线程是无法知道这个变化的。它可能会直接读Cache里的数据。但是很不幸，Cache里的数据已经过期了，读出来的是不合时宜的脏数据。这时就会出现bug。

用Volatile声明变量可以解决这个问题。用Volatile声明的变量就相当于告诉编译器，我不要把这个变量写Cache，因为这个变量是可能发生改变的。

C# Volatile 类

 

关于C#中Volatile类的具体信息，请访问MSDN: https://msdn.microsoft.com/en-us/library/system.threading.volatile(v=vs.110).aspx

在多处理器系统上，Volatile Write操作确保写入存储器位置的值立即对所有处理器可见。 Volatile Read操作获得由任何处理器写入存储器位置的最新值。 这些操作可能需要刷新处理器缓存，这可能会影响性能。

在单处理器系统上，Volatile 读取和写入确保将值读取或写入存储器并且不缓存（例如，在处理器寄存器中）。 因此，您可以使用这些操作来同步对可以由另一个线程或硬件更新的字段的访问。

Volatile存储器操作用于特殊的同步情况，其中正常锁定不是可接受的替代。 在正常情况下，C＃lock语句，Visual Basic SyncLock语句和Monitor类提供了同步访问数据的最简单和最不容易出错的方法，而Lazy <T>类提供了一种简单的方式来编写延迟初始化代码 而无需直接使用双重检查锁定。

volatile（C# 参考）

若要了解有关 Visual Studio 2017 RC 的最新文档，请参阅 Visual Studio 2017 RC 文档。

volatile 关键字指示一个字段可以由多个同时执行的线程修改。 声明为 volatile 的字段不受编译器优化（假定由单个线程访问）的限制。 这样可以确保该字段在任何时间呈现的都是最新的值。

volatile 修饰符通常用于由多个线程访问但不使用 lock 语句对访问进行序列化的字段。

volatile 关键字可应用于以下类型的字段：

• 引用类型。

• 指针类型（在不安全的上下文中）。 请注意，虽然指针本身可以是可变的，但是它指向的对象不能是可变的。 换句话说，您无法声明“指向可变对象的指针”。

• 类型，如 sbyte、byte、short、ushort、int、uint、char、float 和 bool。

• 具有以下基类型之一的枚举类型：byte、sbyte、short、ushort、int 或 uint。

• 已知为引用类型的泛型类型参数。

• IntPtr 和 UIntPtr。

可变关键字仅可应用于类或结构字段。 不能将局部变量声明为 volatile。

理解：

Volatile 字面的意思时易变的，不稳定的。在C#中也差不多可以这样理解。

编译器在优化代码时，可能会把经常用到的代码存在Cache里面，然后下一次调用就直接读取Cache而不是内存，这样就大大提高了效率。但是问题也随之而来了。

在多线程程序中，如果把一个变量放入Cache后，又有其他线程改变了变量的值，那么本线程是无法知道这个变化的。它可能会直接读Cache里的数据。但是很不幸，Cache里的数据已经过期了，读出来的是不合时宜的脏数据。这时就会出现bug。

用Volatile声明变量可以解决这个问题。用Volatile声明的变量就相当于告诉编译器，我不要把这个变量写Cache，因为这个变量是可能发生改变的。

下面贴栗子代码：

using System;
using System.Threading;

namespace demoVolatile
{
    class Program
    {
        //多个线程访问的变量，标记为Volatile
        //在这里如果不标记可能会卖出不止10张票
        volatile static int TicketCount = 10;
        static void SellTicket()
        {
            while (TicketCount > 0)
            {
                TicketCount--;
                Console.WriteLine("{0} 卖出了一张票", Thread.CurrentThread.Name);
            }
            Console.WriteLine("{0} 下班了", Thread.CurrentThread.Name);
        }
        static void Main(string[] args)
        {
            ThreadStart threadWork = new ThreadStart(SellTicket);
            Thread t1 = new Thread(threadWork);
            t1.Name = "t1";
            Thread t2 = new Thread(threadWork);
            t2.Name = "t2";
            Thread t3 = new Thread(threadWork);
            t3.Name = "t3";
            //开始执行
            t1.Start();
            t2.Start();
            t3.Start();
            Console.ReadKey();
        }
    }
}

三、锁

我们都知道，lock 关键字可以用来确保代码块完成运行，而不会被其他线程中断。也就是，说在多线程中，使用lock关键字，可以让被lock的对象，一次只被一个线程使用。

lock语句根本使用的就是Monitor.Enter和Monitor.Exit,也就是说lock(this)时执行Monitor.Enter(this),大括号结束时执行Monitor.Exit(this). 也就是说，Lock关键字，就是一个语法糖而已。

使用lock需要注意的地方：
1.lock不能锁定空值某一对象可以指向Null，但Null是不需要被释放的。（请参考：认识全面的null）
2.lock不能锁定string类型，虽然它也是引用类型的。因为字符串类型被CLR“暂留”
3.lock锁定的对象是一个程序块的内存边界
4.值类型不能被lock，因为前文标红字的“对象被释放”，值类型不是引用类型的
5.lock就避免锁定public 类型或不受程序控制的对象。

using System;
using System.Threading.Tasks;

public class Account
{
    private readonly object balanceLock = new object();
    private decimal balance;

    public Account(decimal initialBalance)
    {
        balance = initialBalance;
    }

    public decimal Debit(decimal amount)
    {
        lock (balanceLock)
        {
            if (balance >= amount)
            {
                Console.WriteLine($"Balance before debit :{balance, 5}");
                Console.WriteLine($"Amount to remove     :{amount, 5}");
                balance = balance - amount;
                Console.WriteLine($"Balance after debit  :{balance, 5}");
                return amount;
            }
            else
            {
                return 0;
            }
        }
    }

    public void Credit(decimal amount)
    {
        lock (balanceLock)
        {
            Console.WriteLine($"Balance before credit:{balance, 5}");
            Console.WriteLine($"Amount to add        :{amount, 5}");
            balance = balance + amount;
            Console.WriteLine($"Balance after credit :{balance, 5}");
        }
    }
}

class AccountTest
{
    static void Main()
    {
        var account = new Account(1000);
        var tasks = new Task[100];
        for (int i = 0; i < tasks.Length; i++)
        {
            tasks[i] = Task.Run(() => RandomlyUpdate(account));
        }
        Task.WaitAll(tasks);
    }

    static void RandomlyUpdate(Account account)
    {
        var rnd = new Random();
        for (int i = 0; i < 10; i++)
        {
            var amount = rnd.Next(1, 100);
            bool doCredit = rnd.NextDouble() < 0.5;
            if (doCredit)
            {
                account.Credit(amount);
            }
            else
            {
                account.Debit(amount);
            }
        }
    }
}

作用：当同一个资源被多个线程读，少个线程写的时候，使用读写锁

引用：https://blog.csdn.net/weixin_40839342/article/details/81189596

问题： 既然读读不互斥，为何还要加读锁

答：     如果只是读，是不需要加锁的，加锁本身就有性能上的损耗

如果读可以不是最新数据，也不需要加锁

如果读必须是最新数据，必须加读写锁

读写锁相较于互斥锁的优点仅仅是允许读读的并发，除此之外并无其他。

注意：不要使用ReaderWriterLock，该类有问题