线程安全的几种解决方案

线程能访问什么

在讲线程安全之前,我们需要对线程本身有一些更深的认识。众所周知,一个进程里可以拥有多个线程,其中有一个主线程。同一个进程的各个线程使用同一个虚拟内存地址空间,这意味着从系统层面上,线程之间是可以互相共享彼此的数据的。但是从编程语言层面上,线程的访问受到了一定的限制,我们需要明白:在C#中,线程可以访问什么数据?

首先,所有线程都可以访问全局变量,因为全局变量具有最大的作用域。

其次,线程可以访问局部变量,只需要线程执行到此函数即可,局部变量储存在栈中,生命周期即是函数执行时期,其他线程也可以在函数结束前访问此变量,如果当前执行的线程可以将变量地址传达出去的话。

不同的线程的局部变量,储存在不同的栈中。这是因为线程可以拥有自己的栈,下面是来自《操作系统导论》的一张图片,左边是单线程程序的内存,其中主线程的栈在最底下,而右边是拥有两个线程的程序的内存,其中两个线程分别拥有自己的栈(图中是Stack1和Stack2)。

最后,线程也可以拥有自己的私有变量,称为线程变量。线程变量其实是储存在堆中的,堆在进程中属于公共区域,所以这里的线程变量其实指的是逻辑关系,即虽然储存在公共堆中,但是线程变量被某一个特定的线程“认领”了,每个线程只能访问属于自己的拷贝,而不能访问其他线程的。在C#中,这样的变量通过 ThreadLocal 实现,下文会讲到。

什么是“线程安全”

既然各个线程可以访问同一份数据,例如所有线程访问同一个全局变量,那么在访问过程就可能会发送干扰。例如下面这段代码:

using System;
using System.Threading;

namespace Test
{
    class Program
    {
        static int count = 0;
        static void Main(string[] args)
        {
            Thread thread = new Thread(adder);
            thread.Start();
            for (int i = 0; i < 1000000; i++)
            {
                count++;
            }
            thread.Join();
            Console.WriteLine(count);
        }

        static void adder()
        {
            for (int i = 0; i < 1000000; i++)
            {
                count++;
            }
        }
    }
}

这段代码实现两个线程同时对一个全局变量递增100万次,但是最后输出的结果却不是2000000,而是比这个低的一个随机值。这是因为产生了干扰,对于变量递增,我们可以简单看作是三个步骤:

  1. 从内存中读取变量当前的值
  2. 将该值递增
  3. 将新的值写入内存

在两个线程执行递增的时候,可能会出现下面这种情况:

  • 线程一执行了步骤1,记录了count的值,然后执行了步骤2
  • 在线程一执行步骤3之前,线程二执行了步骤3
  • count变量递增,线程一在步骤1所记录的值不再是当前的值
  • 线程一继续执行步骤3,将递增的值写入内存

在上面这个流程中,两个线程分别执行了一次递增,结果应该是count增加了2,但实际上count变量只增加了1。究其原因,是因为递增这个操作可能存在中间态。如果某个操作要么还未执行,要么已经执行完毕,只有这两种状态的话,我们称它为原子的,显然这里的递增不是原子的。

如果一个变量,在多个线程访问的时候不会出现互相破坏的情况,我们就称这个变量是线程安全的,显然,使用原子操作是实现线程安全的一种方式,接下来我们会介绍其他几种方法。

使用局部变量

上面说了,线程拥有自己的栈,而线程如果没有变量的地址,是无法访问其他线程的栈变量的,所以局部变量是线程安全的。在不影响效果的情况下,我们可以将线程所需要的数据作为函数参数传入,线程在自己的栈内对数据进行处理。当然,这种方法过于局限,因为数据的使用范围被限制了,很多时候我们需要多个线程同时修改同一个数据,使用局部变量就不行了。

使用线程变量

使用线程变量,可以把一个上下文注入线程内部,各个线程拥有一份这个数据的拷贝,而不会产生破坏,C#通过 ThreadLocal 创建一个线程变量,如下面的代码:

using System;
using System.Threading;

namespace Test
{
    class Program
    {
        static ThreadLocal<string> threadLocal = new ThreadLocal<string>();
        static void Main(string[] args)
        {
            threadLocal.Value = "A";
            Console.WriteLine("threadID:{0}, value:{1}", Environment.CurrentManagedThreadId, threadLocal.Value);

            Thread thread1 = new Thread(() =>
            {
                threadLocal.Value = "B";
                Console.WriteLine("threadID:{0}, value:{1}", Environment.CurrentManagedThreadId, threadLocal.Value);
            });

            Thread thread2 = new Thread(() =>
            {
                threadLocal.Value = "C";
                Console.WriteLine("threadID:{0}, value:{1}", Environment.CurrentManagedThreadId, threadLocal.Value);
            });

            thread1.Start();
            thread1.Join();
            Console.WriteLine("threadID:{0}, value:{1}", Environment.CurrentManagedThreadId, threadLocal.Value);
            thread2.Start();
            thread2.Join();
            Console.WriteLine("threadID:{0}, value:{1}", Environment.CurrentManagedThreadId, threadLocal.Value);
        }

    }
}

输出结果是

threadID:1, value:A
threadID:5, value:B
threadID:1, value:A
threadID:6, value:C
threadID:1, value:A

可以看到各个线程之间的值是独立的,即每个线程都有一份 threadLocal 的拷贝。从效果上看,线程变量和局部变量是一样的,但使用线程变量更好。例如,当你重构代码,需要为一个线程方法注入新数据时,使用局部变量需要改变方法的签名(例如在类的构造函数中加入一个新参数),这样对接口的破坏性极大,这个时候使用 ThreadLocal 更好。另一方面,一个 ThreadLocal 对象便可以被所有线程访问,拷贝是自动创建的,而不需要手动编写代码。

线程变量和局部变量有一样的缺点,那就是无法支持多个线程同时地修改同一个数据。

使用互斥锁

如果要支持多个线程安全、同时地修改同一个数据,最常用的方法就是使用锁。锁可以确保数据在某一时刻只可以被某一个线程操作:当线程需要操作数据时,它可以尝试获取锁,如果锁空闲,线程就持有该锁,并对数据进行操作,而其他线程尝试获取锁时,锁被占用,线程就必须等待锁被释放,直到自己持有该锁。即哪个线程拥有锁,哪个线程就可以操作数据。对最开始的例子进行修改:

class Program 
{ 
    static int count = 0;
    private static readonly object countLock = new object();
    static void Main(string[] args) 
    { 
        Thread thread = new Thread(adder); 
        thread.Start(); 
        for (int i = 0; i < 1000000; i++)
        {
            lock(countLock){ count++; }
        } 
        thread.Join(); Console.WriteLine(count); 
    }

    static void adder() 
    { 
        for (int i = 0; i < 1000000; i++) 
        {
            lock (countLock) { count++; }
        } 
    }
}

使用 lock 关键字,获取指定对象(代码中是countlock)的锁,执行代码块,然后释放锁。这里代码块中对count递增,最后输出的结果一定是2000000。代码中声明的是私有的、静态的、只读的对象,这样可以防止外部改变锁的状态。

lock 关键字,是C#中使用互斥锁的最简单的方法,但是 lock 可能会导致死锁,更完善的方法是使用 Monitor 或者 Mutex,这里不再详细说明。

使用乐观锁

在上面的代码中,虽然我们使用锁保证了线程安全,但是有些时候我们不需要这么严格,例如在线程比较少的时候,数据不安全的概率自然比较低,而频繁地获取和释放锁是有性能代价的,这个时候就可以使用乐观锁。

本质上乐观锁并没有加锁,而是基于一种叫CAS(Compare And Swap)的方法,具体来说:当一个线程访问了一项数据,在操作之前它先将当前的数据状态记录下来,等它操作结束后写入数据前,将自己之前记录的状态与数据当前的状态进行比较,如果相同,说明没有其他线程中途修改了这个数据,这个时候线程认为写入是安全的。如果不同,说明数据被其他线程修改了,那么线程可以选择取消当前操作,并进行重试(也可以是其他处理方法)。

乐观锁是保持乐观态度的,只有当它发现数据可能存在危险的时候,它才进行处理。对于比较安全的场景来说,例如线程数量少,并发量低的场景,乐观锁的性能代价是很低的。但是,如果数据存在危险的概率很大,那么乐观锁的性能代价则会高于悲观锁,因为乐观锁对危险情况的处理的成本(例如重试)远高于获取/释放悲观锁的成本,这个时候还不如直接加锁。所以,要根据实际情况灵活选择。

上面的CAS方法其实是有缺陷的,那就是“ABA”问题:当线程比较数据时,如果数据相同,并不能断定没有其他线程修改过该数据,可能数据最开始是A,被某个线程修改为B,又被另一个线程修改回A,这个时候数据其实已经被篡改了。为了防止这种情况,可以为数据增加一个版本号,每次修改递增版本号,通过比较版本号来判断。