基元线程同步——Interlocked Anything模式

上一篇基元线程同步——基础,非阻塞同步(VolatileRead,VolatileWrite,volatile,Interlocked) 已经对Interlocked类做了比较详细的分析,这一篇是对Interlocked类的一个模式进行补充说明。如果没用过Interlocked类,可以看看上面的这篇文章。

这个模式的名字是Jeffrey给起的,它究竟要解决什么问题,我们为什么要用它?带着这些疑问,我们来看看它的应用场景。

看看下面这个设定最大值的例子:

        private static Int32 Maximum(ref int target, int value)
        {
            int oldValue;
            oldValue = target;

            //计算最大值
            int temp = Math.Max(target, value);

            //注意:这里可能有其他线程恰好修改了target的值

            //如果target是oldValue,则替换成最大的值
            Interlocked.CompareExchange(ref target, temp, oldValue);

            return target;
        }

测试代码:

            int v1 = 10;

            v1 = Maximum(ref v1, 20);
            Console.WriteLine("v1:" + v1);

如果恰好有一个线程在Interlocked.CompareExchange这句代码执行前修改了target的值为15,那么我们这里的最大值20就不会生效,因为CompareExchange的比较条件将会失败。我们得到的输出,有可能是:v1:15。

这样的结果可能不是我们的预期,问题在于上面的代码只调用了CompareExchange一次,如果不成功就跳过了这次修改。所以,我们可以考虑对CompareExchange做一个循环判断,不成功就再度尝试修改,直到成功为止。而这正是Jeffery所说的Interlock Anything模式。

我们进一步修改上面的代码:

        private static Int32 Maximum(ref int target, int value)
        {
            int oldValue, currentValue;

            currentValue = target;
            do
            {
                //oldValue记录当前循环开始时的原始值
                oldValue = currentValue;

                //计算最大值
                int temp = Math.Max(target, value);

                //注意:这里可能有其他线程恰好修改了target的值

                //如果target是oldValue,则替换成最大的值。
                //如果被其他线程修改了,currentValue返回的将会是被其他线程修改后的最新值,比如:15
                currentValue = Interlocked.CompareExchange(ref target, temp, oldValue);
            }
            while (currentValue != oldValue);//如果被修该,则进入下一次循环,尝试再次修改

            return target;
        }

注释中已经写得很清楚了,可能你需要反复的思考一下上面的代码,理解其意图。这里只是对Int32的值进行了修改,利用这个模式实际可以对任何引用类型的值进行修改。从而避免多线程访问共同变量带来的冲突。

对于这个模式的应用,我们看看微软给我们的示范:在实现事件(Event)时是如何运用了这个模式的。

首先定义下面的一个事件:

        public delegate bool UploadFileCompleteEventHander(string fileName);
        public event UploadFileCompleteEventHander UploadFileComplete;

我们知道,事件本身还是用代理来实现的,只不过编译器帮我们做了这部分工作,反编译这个事件的代码:

public event UploadFileCompleteEventHander UploadFileComplete
{
    add
    {
        UploadFileCompleteEventHander hander2;
        UploadFileCompleteEventHander uploadFileComplete = this.UploadFileComplete;
        do
        {
            hander2 = uploadFileComplete;
            UploadFileCompleteEventHander hander3 = (UploadFileCompleteEventHander) Delegate.Combine(hander2, value);
            uploadFileComplete = Interlocked.CompareExchange<UploadFileCompleteEventHander>(ref this.UploadFileComplete, hander3, hander2);
        }
        while (uploadFileComplete != hander2);
    }
    remove
    {
        UploadFileCompleteEventHander hander2;
        UploadFileCompleteEventHander uploadFileComplete = this.UploadFileComplete;
        do
        {
            hander2 = uploadFileComplete;
            UploadFileCompleteEventHander hander3 = (UploadFileCompleteEventHander) Delegate.Remove(hander2, value);
            uploadFileComplete = Interlocked.CompareExchange<UploadFileCompleteEventHander>(ref this.UploadFileComplete, hander3, hander2);
        }
        while (uploadFileComplete != hander2);
    }
}

看见了吗,上面的add和Remove方法,对代理的添加和删除就是用的这个模式,多么经典。保证多个线程注册一个事件时,不会出现冲突。

总结:

1,一个变量可能被多线程访问时,可以考虑运用这个模式。

2,它的速度比阻塞式同步,如lock等,要快很多。

3,它能对任何类型的变量进行赋值,而不仅仅局限于Int32,等原子操作类型。

你可能感兴趣的:(Lock)