• C#线程系列讲座(4):同步与死锁


    本文为原创,如需转载,请注明作者和出处,谢谢!

    上一篇C#线程系列讲座(3):线程池和文件下载服务器


     
    虽然线程可以在一定程度上提高程序运行的效率,但也会产生一些副作用。让我们先看看如下的代码:

        class Increment
        {
            
    private int n = 0;
            
    private int max;
            
    public Increment(int max)
            {
                
    this.max = max;
            }
            
    public int result
            {
                
    get
                {
                    
    return n;
                }
                
    set
                {
                    n 
    = value;
                }
            }
            
    public void Inc()
            {            
                
    for (int i = 0; i < max; i++)
                {
                    n
    ++;
                }
            }
        }
        
    class Program
        {
            
    public static void Main()
            {
                Increment inc 
    = new Increment(10000);
                Thread[] threads 
    = new Thread[30];
                
    for (int i = 0; i < threads.Length; i++)
                {
                    threads[i] 
    = new Thread(inc.Inc);
                    threads[i].Start();
                }
                
    for (int i = 0; i < threads.Length; i++)
                {
                    threads[i].Join();  
    // 等待30个线程都执行完
                }
                Console.WriteLine(inc.result);  
    //输出n的值

            }

        }


        上面的程序的基本功能是使用IncrementInc方法为n递增max,所不同的是,将在Main方法中启动30个线程同时执行Inc方法。在本例中max的值是10000(通过Increment的构造方法传入)。读者可以运行一下这个程序,正常的结果应该是300000,但通常不会得到这个结果,一般获得的结果都比300000小。其中的原因就是Inc方法中的n++上,虽然从表面上看,n++只是一条简单的自增语言,但从底层分析,n++IL代码如下:

    ldsfld //
    获得n的初始值,并压到方法栈中

    ldc.i4.1 // 1压到方法栈中

    add // 从方法栈中弹出最顶端的两个值,相加,然后将结果保存在方法栈中

    stfld // 从当前方法栈中弹出一个值,并更新类字段n

        对于上面每一条IL语句是线程安全的,但是n++这条C#语句需要上面的四步才能完成,因此,n++这条语句并不是线程安全的。只要在执行stfld指令之前的任何一步由于其他线程获得CPU而中断,那么就会出现所谓的“脏”数据。

        假设n的初始值为0 thread1在执行完ldc.i4.1后被thread2中断(add指令并未执行),这时thread2获得的n的初始值仍然是0,假设thread2顺利执行完,那么这时n的值已经是1了,当thread2执行完后,thread1继续执行add指令,并且thread1也顺利执行完,这时,在thread1中的执行结果n仍然是1。因此,这也就出现了调用两次n++n仍然为1的情况。要解决这个问题的方法也很容易想到,就是让上述四条IL语句要不都不执行,要执行就都执行完,这有点事务处理的意思。

        C#中解决这个问题的技术叫同步。同步的本质就是为某一个代码块加锁,使其成为一个整体,共同进退。最简单的是使用lock为代码块加锁。这个语句在前几讲已经多次使用过了。lock语句可以锁定任何的对象,如果锁定的是类成员,直接使用lock(obj)的形式即可,如果锁定的是静态成员,可以把锁主在object类型上,代码如下:

    lock(typeof(StaticClass))

    {

       ... ...

    }

        对于Increment类,我们可以锁定n++,也可以锁定Inc方法,如锁定n++Increment类的代码如下:

        class Increment
        {
            
    private int n = 0;
            
    private int max;
            
    private Object lockN = new Object();
            
    public Increment(int max)
            {
                
    this.max = max;
            }
            
    public int result
            {
                
    get
                {
                    
    return n;
                }
                
    set
                {
                    n 
    = value;
                }
            }

            
    private void IncN()
            {
                
    lock (lockN)
                {
                    n
    ++;
                }
            }
            
    public void Inc()
            {
                
    for (int i = 0; i < max; i++)
                {
                      IncN();
                }           
            }
        }


       
    也可以直接将如下的代码放到for循环中取代调用IncN方法,


     lock (lockN)
     {
         n
    ++;
     }

    或者直接将Inc方法锁住,代码如下:

            public void Inc()
            {
                
    lock (lockN)
                {
                    
    for (int i = 0; i < max; i++)
                    {
                        n
    ++;
                    }
                }
            }

        但笔者并不建议直接将Inc锁住,因为这样就和单线程没什么区别了,虽然可以避免出现读脏数据的情况,但却牺牲的效率。

        从本例分析得知,产生问题的原因就是因为n++不是原子操作。而在.net framework中提供了一个Interlocked类,可以使n++变成原子操作。Interlocked有一些方法,可以保证对变量的操作是原子的,如Increment方法保证n++的操作是原子的,Decrement方法保证n--的操作是原子的,Exchange方法保证为变量赋值的操作是原子的。因此,可以使用Increment方法来替换n++,代码如下:

    public void Inc()
    {
        
    for (int i = 0; i < max; i++)
        {
            Interlocked.Increment(
    ref n);
        }
    }


        任何事物都具有两面性,同步技术也不例外,在某些情况下,可以由于两个线程互相锁定某些对象而造成死锁(就是两个线程互相等待对方释放对象)。这就象有两个学生晚上在复习功课,他们都希望学习能超过对方,而且他们都很累了,但是谁也不肯先休息,是都在盯着对方屋里的灯,期望着对方休息后。自己才休息。但却谁也不肯先关灯,所以他们就只有这样耗到天亮了。当然,解决这个问题的方法有两个,第一个就是其中一个学生或两个学生根本就不关心对方是否先睡觉,自己学累了就直接关灯了。当然,另外一个方法就有点暴力了,就是到点就直接断电,那谁也别学了(这也相当于线程中断,不过不到万不得以时最好别用这招)。

        让我们先举一个线程死锁的例子,代码如下:

        class Program
        {
            
    private static Object objA = new Object();
            
    private static Object objB = new Object();
            
    public static void LockA()
            {
                
    lock (objA)
                {
                    Thread.Sleep(
    1000);
                    
    lock (objB)
                    {
                    }
                }
                Console.WriteLine(
    "LockA");
            }
            
    public static void LockB()
            {
                
    lock (objB)
                {
                    Thread.Sleep(
    2000);
                    
    lock (objA)
                    {
                    }
                }
                Console.WriteLine(
    "LockB");
            }
            
    public static void Main()
            {
                Thread threadA 
    = new Thread(LockA);
                Thread threadB 
    = new Thread(LockB);
                threadA.Start();
                threadB.Start();
            }
        }


        在上面的代码中,LockA方法会在当前线程中执行完Lock(objA)后延迟1秒,而LockB方法会在执行完lock(objB)后延迟2秒,一般LockA会先执行lock(objB),但这时objB已经被LockB锁住了,而且LockB还在延迟(2秒还没到)。在这时,LockA已经将objAobjB都锁上了,当LockB执行到lock(objA)时,由于objA已经被锁上,因此,LockB就被阻塞了。而LockA在执行到lock(objB)时,由于这时LockA还在延迟,因此,objB也被锁住了。LockALockB也就相当于上述的两个学生,互相等待对方关灯,但谁也不肯先关灯,所以就死锁了。如果采用第一种方法非常简单,就是保持被锁定的多个对象的顺序,如将LockB方法的锁定顺序换一下,代码如下:

    public static void LockB()
    {
        
    lock (objA)
        {
             Thread.Sleep(
    2000);
              
    lock (objB)
              {
              }
        }
        Console.WriteLine(
    "LockB");
    }


        或是将LockA方法也改一下,先锁objB,再锁objA

        当然,也可以采用暴力一点的方法,当发现一些线程长时间没反应时,可以使用Abort方法强行中断它们。代码如下:
    public static void Main()
    {
         Thread threadA 
    = new Thread(LockA);
         Thread threadB 
    = new Thread(LockB);
         threadA.Start();
         threadB.Start();

         Thread.Sleep(
    4000);

         threadA.Abort();
         threadB.Abort();
         Console.WriteLine(
    "线程全部结束");
    }

        在后面的文章中将讲解C#中其他的同步技术。

    下一篇:
    C#线程系列讲座(5):同步技术之Monitor

  • 相关阅读:
    在Kubernetes集群里安装微服务DevOps平台fabric8
    Kubernetes PV/PVC使用实践
    Kubernetes集群中Service的滚动更新
    jenkins权限管理,不同用户显示不同项目
    SSH连接与自动化部署工具paramiko与Fabric
    kubernetes 之ingress
    理解Docker(8):Docker 存储之卷(Volume)
    Rancher Server HA的高可用部署实验-学习笔记
    2015 年总结
    2015 年总结
  • 原文地址:https://www.cnblogs.com/nokiaguy/p/1251756.html
Copyright © 2020-2023  润新知