.NET：通过 CAS 来理解数据库乐观并发控制，顺便给出无锁的 RingBuffer。

背景

大多数企业开发人员都理解数据库乐观并发控制，不过很少有人听说过 CAS（我去年才听说这个概念），CAS 是多线程乐观并发控制策略的一种，一些无锁的支持并发的数据结构都会使用到 CAS，本文对比 CAS 和 数据库乐观并发控制，以此达到强化记忆的目的。

CAS

CAS = Compare And Swap

多线程环境下 this.i = this.i + 1 是没有办法保证线程安全的，因此就有了 CAS，CAS 可以保证上面代码的线程安全性，但是 CAS 并不会保证 Swap 的成功，只有 Compare 成功了才会 Swap，即：没有并发发生，即：在我读取和修改之间没有别人修改。另外说一点，如果 i 是局部变量，即：i = i + 1，那么这段代码是线程安全的，因为局部变量是线程独享的。

不明白 CAS 没关系，下面通过 CAS 的标准模式 和 一个简单的示例来理解 CAS。

CAS 的标准模式

伪代码

 1                     var localValue, currentValue;
 2                     do
 3                     {
 4                         localValue = this.
 5
 6                         var newValue = 执行一些计算;
 7
 8                         currentValue = Interlocked.CompareExchange(ref this.value, newValue, localValue);
 9                     } while (localValue != currentValue);

说明

把 this.value 看成是数据库数据，localValue 是某个用户读取的数据，newValue是用户想修改的值，这里有必要解释一下 CompareExchange 和 currentValue，它的内部实现代码是这样的（想想下面代码是线程安全的）：

1 var currentValue = this.value
2 if(currentValue == localValue){
3    this.value = newValue;
4 }
5 return currentValue;

CompareExchange  用 sql 来类比就是：update xxx set value = newValue where value = localValue，只不过返回的值不同。通过 CompareExchange 的返回结果我们知道 CAS 是否成功了，即：是否出现并发了，即：是否在我读取和修改之间别人已经修改过了，如果是，可以选择重试。

累加示例

CAS 代码

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

 namespace InterlockStudy
 {
     class ConcurrentIncrease
     {
         public static void Test()
         {
             var sum = ;

             var tasks = new Task[];
             for (var i = ; i <= ; i++)
             {
                 tasks[i - ] = Task.Factory.StartNew((state) =>
                 {
                     int localSum, currentSum;
                     do
                     {
                         localSum = sum;

                         Thread.Sleep();
                         var value = (int)state;
                         var newValue = localSum + value;

                         currentSum = Interlocked.CompareExchange(ref sum, newValue, localSum);
                     } while (localSum != currentSum);
                 }, i);
             }

             Task.WaitAll(tasks);

             Console.WriteLine(sum);
         }
     }
 }

数据库并发代码

         public static void Test13()
         {
             var tasks = new Task[];
             for (var i = ; i <= ; i++)
             {
                 tasks[i - ] = Task.Factory.StartNew((state) =>
                 {
                     int localSum, result;
                     do
                     {
                         using (var con = new SqlConnection(CONNECTION_STRING))
                         {
                             con.Open();
                             var cmd = new SqlCommand("select sum from Tests where Id = 1", con);
                             var reader = cmd.ExecuteReader();
                             reader.Read();
                             localSum = reader.GetInt32();

                             System.Threading.Thread.Sleep();
                             var value = (int)state;
                             var newValue = localSum + value;

                             cmd = new SqlCommand("update Tests set sum = " + newValue + " where sum = " + localSum + "", con);
                             result = cmd.ExecuteNonQuery();
                         }
                     } while (result == );
                 }, i);
             }

             Task.WaitAll(tasks);
         }
     }

说明

我们发现 CAS 版本的代码和数据库版本的代码出奇的相似，数据库的CAS操作是通过 update + where 来完成的。

写着玩的 RingBuffer

代码

 using System;
 using System.Collections.Generic;
 using System.Collections.Concurrent;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 using System.Threading;

 namespace InterlockStudy
 {
     internal class Node<T>
     {
         public T Data { get; set; }

         public bool HasValue { get; set; }
     }

     class RingBuffer<T>
     {
         private readonly Node<T>[] _nodes;
         private long _tailIndex = -;
         private long _headIndex = -;
         private AutoResetEvent _readEvent = new AutoResetEvent(false);
         private AutoResetEvent _writeEvent = new AutoResetEvent(false);

         public RingBuffer(int maxSize)
         {
             _nodes = new Node<T>[maxSize];

             for (var i = ; i < maxSize; i++)
             {
                 _nodes[i] = new Node<T>();
             }
         }

         public void EnQueue(T data)
         {
             while (true)
             {
                 if (this.TryEnQueue(data))
                 {
                     _readEvent.Set();
                     return;
                 }

                 _writeEvent.WaitOne();
             }

         }

         public T DeQueue()
         {
             while (true)
             {
                 T data;
                 if (this.TryDeQueue(out data))
                 {
                     _writeEvent.Set();
                     return data;
                 }

                 _readEvent.WaitOne();
             }

         }

         public bool TryEnQueue(T data)
         {
             long localTailIndex, newTailIndex, currentTailIndex;
             do
             {
                 localTailIndex = _tailIndex;

                 if (!this.CanWrite(localTailIndex))
                 {
                     return false;
                 }

                 newTailIndex = localTailIndex + ;

                 if (_nodes[newTailIndex % _nodes.Length].HasValue)
                 {
                     return false;
                 }

                 currentTailIndex = Interlocked.CompareExchange(ref _tailIndex, newTailIndex, localTailIndex);
             }
             while (localTailIndex != currentTailIndex);

             _nodes[newTailIndex % _nodes.Length].Data = data;
             _nodes[newTailIndex % _nodes.Length].HasValue = true;

             return true;
         }

         public bool TryDeQueue(out T data)
         {
             long localHeadIndex, newHeadIndex, currentHeadIndex;
             do
             {
                 localHeadIndex = _headIndex;

                 if (!this.CanRead(localHeadIndex))
                 {
                     data = default(T);
                     return false;
                 }

                 newHeadIndex = localHeadIndex + ;
                 if (_nodes[newHeadIndex % _nodes.Length].HasValue == false)
                 {
                     data = default(T);
                     return false;
                 }

                 currentHeadIndex = Interlocked.CompareExchange(ref _headIndex, newHeadIndex, localHeadIndex);
             }
             while (localHeadIndex != currentHeadIndex);

             data = _nodes[newHeadIndex % _nodes.Length].Data;
             _nodes[newHeadIndex % _nodes.Length].HasValue = false;

             return true;
         }

         private bool CanWrite(long localTailIndex)
         {
             return localTailIndex - _headIndex < _nodes.Length;
         }

         private bool CanRead(long localHeadIndex)
         {
             return _tailIndex - localHeadIndex > ;
         }
     }
 }

备注

仓促成文，如果有必要可以再写篇文章，希望大家多批评。