• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号

编写高质量代码改善C#程序的157个建议——建议73:避免锁定不恰当的同步对象 ...

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

建议73:避免锁定不恰当的同步对象

在C#中,让线程同步的另一种编码方式就是使用线程锁。线程锁的原理,就是锁住一个资源,使得应用程序在此刻只有一个线程访问该资源。通俗地讲,就是让多线程变成单线程。在C#中,可以将被锁定的资源理解成new出来的普通CLR对象。

既然需要锁定的资源就是C#中的一个对象,我们就该仔细思考,到底什么样的对象能够成为一个锁对象(也叫同步对象)?在选择同步对象的时候,应当始终注意以下几点:

1)同步对象在需要同步的多个线程中是可见的同一个对象。
2)在非静态方法中,静态变量不应作为同步对象。
3)值类型对象不能作为同步对象。
4)避免将字符串作为同步对象。
5)降低同步对象的可见性。

下面分别详细介绍以上五个注意事项。

第一个注意事项:需要锁定的对象在多个线程中是可见的,而且是同一个对象。“可见的”这是显而易见的,如果对象不可见,就不能被锁定。“同一个对象”,这也很容易理解,如果锁定的不是同一个对象,那又如何来同步两个对象呢?虽然理解起来简单,但不见得我们在这上面就不会犯错误。为了帮助大家理解本建议的内容,我们先模拟一个必须使用到锁的场景:在遍历一个集合的过程中,同时在另外一个线程中删除集合中的某项。下面这个例子中,如果没有lock语句,将会抛出异常InvalidOperationException:“集合已修改;可能无法执行枚举”:

public partial class FormMain : Form  
{  
    public FormMain()  
    {  
        InitializeComponent();  
    }  
 
    AutoResetEvent autoSet = new AutoResetEvent(false);  
    List<string> tempList = new List<string>() { "init0", "init1", "init2" };  
 
    private void buttonStartThreads_Click(object sender, EventArgs e)  
    {  
        object syncObj = new object();  
 
        Thread t1 = new Thread(() =>
        {  
            //确保等待t2开始之后才运行下面的代码  
            autoSet.WaitOne();  
            lock (syncObj)  
            {  
                foreach (var item in tempList)  
                {  
                    Thread.Sleep(1000);  
                }  
            }  
        });  
        t1.IsBackground = true;  
        t1.Start();  
 
        Thread t2 = new Thread(() =>
        {  
            //通知t1可以执行代码  
            autoSet.Set();  
            //沉睡1秒是为了确保删除操作在t1的迭代过程中  
            Thread.Sleep(1000);  
            lock (syncObj)  
            {  
                tempList.RemoveAt(1);  
            }  
        });  
        t2.IsBackground = true;  
        t2.Start();  
    }  
} 

 


这是一个Winform窗体应用程序,需要演示的功能在按钮的单击事件中。对象syncObj对于线程t1和t2来说,在CLR中肯定是同一个对象。所以,上面的示例运行是没有问题的。

现在,我们将此示例重构。将实际的工作代码移到一个类型SampleClass中,该示例要在多个SampleClass实例间操作一个静态字段,如下所示:

private void buttonStartThreads_Click(object sender, EventArgs e)  
{  
    SampleClass sample1 = new SampleClass();  
    SampleClass sample2 = new SampleClass();  
    sample1.StartT1();  
    sample2.StartT2();  
}  
 
class SampleClass  
{  
    public static List<string> TempList = new List<string>() { "init0",   
        "init1", "init2" };  
    static AutoResetEvent autoSet = new AutoResetEvent(false);  
    object syncObj = new object();  
          
    public void StartT1()  
    {  
        Thread t1 = new Thread(() =>
        {  
            //确保等待t2开始之后才运行下面的代码  
            autoSet.WaitOne();  
            lock (syncObj)  
            {  
                foreach (var item in TempList)  
                {  
                    Thread.Sleep(1000);  
                }  
            }  
        });  
        t1.IsBackground = true;  
        t1.Start();  
    }  
 
    public void StartT2()  
    {  
        Thread t2 = new Thread(() =>
        {  
            //通知t1可以执行代码  
            autoSet.Set();  
            //沉睡1秒是为了确保删除操作在t1的迭代过程中  
            Thread.Sleep(1000);  
            lock (syncObj)  
            {  
                TempList.RemoveAt(1);  
            }  
        });  
        t2.IsBackground = true;  
        t2.Start();  
    }  
}

 


该示例运行起来会抛出异常InvalidOperationException:

“集合已修改;可能无法执行枚举。”

查看类型SampleClass的方法StartT1和StartT2,方法内部锁定的是SampleClass的实例变量syncObject。实例变量意味着,每创建一个SampleClass的实例都会生成一个syncObject对象。在本例中,调用者一共创建了两个SampleClass实例,继而分别调用:

sample1.StartT1();  
sample2.StartT2();
也就是说,以上代码锁定的是两个不同的syncObject,这等于完全没有达到两个线程锁定同一个对象的目的。要修正以上错误,只要将syncObject变成static就可以了。

另外,思考一下lock(this),我们同样不建议在代码中编写这样的代码。如果两个对象的实例分别执行了锁定的代码,实际锁定的也就会是两个对象,完全不能达到同步的目的。

第二个注意事项:在非静态方法中,静态变量不应作为同步对象。也许有读者会问,前面曾说到,要修正第一个注意事项中的示例问题,需要将syncObject变成static。这似乎和本注意事项有矛盾。事实上,第一个注意事项中的示例代码仅仅出于演示的目的,在实际应用中,我们强烈建议不要编写此类代码。在编写多线程代码时,要遵循这样的一个原则:

类型的静态方法应当保证线程安全,非静态方法不需实现线程安全。

FCL中的绝大部分类都遵循了这个原则。像上一个示例中,如果将syncObject变成static,就相当于让非静态方法具备了线程安全性,这带来的一个问题是,如果应用程序中该类型存在多个实例,在遇到这个锁的时候,它们都会产生同步,而这可能不是开发者所愿意看到的。第二个注意事项实际也可以归纳到第一个注意事项中。

第三个注意事项:值类型对象不能作为同步对象。值类型在传递到另一个线程的时候,会创建一个副本,这相当于每个线程锁定的也是两个对象。因此,值类型对象不能作为同步对象。

第四个注意事项:锁定字符串是完全没有必要的,而且相当危险。这整个过程看上去和值类型正好相反。字符串在CLR中会被暂存到内存里,如果有两个变量被分配了相同内容的字符串,那么这两个引用会被指向同一块内存。所以,如果有两个地方同时使用了lock(“abc”),那么它们实际锁定的是同一个对象,这会导致整个应用程序被阻滞。

第五个注意事项:降低同步对象的可见性。可见范围最广的一种同步对象是typeof(SampleClass)。typeof方法所返回的结果(也就是类型的type)是SampleClass的所有实例所共有的,即:所有实例的type都指向typeof方法的结果。这样一来,如果我们lock(typeof(SampleClass)),当前应用程序中所有SampleClass的实例线程将会全部被同步。这样编码完全没有必要,而且这样的同步对象太开放了。

一般来说,同步对象也不应该是一个公共变量或属性。在FCL的早期版本中,一些常用的集合类型(如ArrayList)提供了公共属性SyncRoot,让我们锁定以便进行一些线程安全的操作。所以你一定会觉得我们刚才的结论不正确。其实不然,ArrayList操作的大部分应用场景不涉及多线程同步,所以它的方法更多的是单线程应用场景。线程同步是一个非常耗时(低效)的操作。若ArrayList的所有非静态方法都要考虑线程安全,那么ArrayList完全可以将这个SyncRoot变成静态私有的。现在它将SyncRoot变为公开的,是让调用者自己去决定操作是否需要线程安全。我们在编写代码时,除非有这样的要求,否则就应该始终考虑降低同步对象的可见性,将同步对象藏起来,只开放给自己或自己的子类就够了(需要开放给子类的情况其实也不多)。

 

 

转自:《编写高质量代码改善C#程序的157个建议》陆敏技


鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
上一篇:
JS or C#?不存在的脚本之争发布时间:2022-07-10
下一篇:
C#基础04发布时间:2022-07-10
热门推荐
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap