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


    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的值         }
    } 

上面的程序的基本功能是使用Increment的Inc方法为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已经将objA和objB都锁上了,当LockB执行到lock(objA)时,由于objA已经被锁上,因此,LockB就被阻塞了。而LockA在执行到lock(objB)时,由于这时LockA还在延迟,因此,objB也被锁住了。LockA和LockB也就相当于上述的两个学生,互相等待对方关灯,但谁也不肯先关灯,所以就死锁了。如果采用第一种方法非常简单,就是保持被锁定的多个对象的顺序,如将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#线程系列讲座(4):同步与死锁的更多相关文章

  1. C#线程系列讲座(5):同步技术之Monitor

    在上一讲介绍了使用lock来实现线程之间的同步.实际上,这个lock是C#的一个障眼法,在C#编译器编译lock语句时,将其编译成了调用Monitor类.先看看下面的C#源代码: public sta ...

  2. 转:C#线程系列讲座(1) BeginInvoke和EndInvoke方法

    转载自:http://www.cnblogs.com/levin9/articles/2319248.html 开发语言:C#3.0IDE:Visual Studio 2008本系列教程主要包括如下内 ...

  3. C#线程系列讲座(2):Thread类的应用

    一.Thread类的基本用法 通过System.Threading.Thread类可以开始新的线程,并在线程堆栈中运行静态或实例方法.可以通过Thread类的的构造方法传递一个无参数,并且不返回值(返 ...

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

    如果设计一个服务器程序,每当处理用户请求时,都开始一个线程,将会在一定程序上消耗服务器的资源.为此,一个最好的解决方法就是在服务器启动之前,事先创建一些线程对象,然后,当处理客户端请求时,就从这些建好 ...

  5. C#线程系列讲座(1):BeginInvoke和EndInvoke方法

    一.C#线程概述 在操作系统中一个进程至少要包含一个线程,然后,在某些时候需要在同一个进程中同时执行多项任务,或是为了提供程序的性能,将要执行的任务分解成多个子任务执行.这就需要在同一个进程中开启多个 ...

  6. C#:多线程、线程同步与死锁

    推荐阅读: C#线程系列讲座(1):BeginInvoke和EndInvoke方法 C#线程系列讲座(2):Thread类的应用 C#线程系列讲座(3):线程池和文件下载服务器 C#线程系列讲座(4) ...

  7. 线程系列08,实现线程锁的各种方式,使用lock,Montor,Mutex,Semaphore以及线程死锁

    当涉及到多线程共享数据,需要数据同步的时候,就可以考虑使用线程锁了.本篇体验线程锁的各种用法以及线程死锁.主要包括: ※ 使用lock处理数据同步※ 使用Monitor.Enter和Monitor.E ...

  8. 线程系列07,使用lock语句块或Interlocked类型方法保证自增变量的数据同步

    假设多个线程共享一个静态变量,如果让每个线程都执行相同的方法每次让静态变量自增1,这样的做法线程安全吗?能保证自增变量数据同步吗?本篇体验使用lock语句块和Interlocked类型方法保证自增变量 ...

  9. Java之线程,常用方法,线程同步,死锁

    1, 线程的概念 进程与线程 进程:每个进程都有独立的代码和数据空间(进程上下文),进程间的切换会有较大的开销,一个进程包含1--n个线程.(进程是资源分配的最小单位) 线程:同一类线程共享代码和数据 ...

随机推荐

  1. CodeForces 625B 字符串模拟+思维

    题意 给出字符串a与b 可以将a中的单个字符改为# 问最少改多少次 a中就找不到b了 一开始想的是用strstr 因为如果找到 可以将strstr(a,b)-a+1改成# 即改首字母 用while循环 ...

  2. php调用empty出现错误Can't use function return value in write context

    php调用empty出现错误Can't use function return value in write context 2012-10-28 09:33:22 | 11391次阅读 | 评论:0 ...

  3. 嵌入式Linux的FTP服务端软件(stupid-ftpd)

    我自己试没成功 http://blog.csdn.net/gzshun/article/details/7358651

  4. Bootstrap页面布局18 - BS导航路径以及分页器

    导航路径:又叫“面包屑”,功能是让用户知道所处的位置. <!--面包屑--> <ul class='breadcrumb'> <li><a href='#'& ...

  5. python函数参数

    1.位置参数 2.默认参数 指向参数为不可变对象 3.可变参数 **args    一个列表list或是元组tuple 4.关键字参数 **kw,是一个字典dict 5.命名关键字参数 *,

  6. access violation at address General protection fault

    https://en.wikipedia.org/wiki/General_protection_fault In memory errors, the faulting program access ...

  7. Intel Visual Fortran Compiler 11调用lapack库实现并行多处理计算

    采用fortran进行数值计算的朋友们都应该听说过大名鼎鼎的lapack库,我就不多做介绍了,在此,我只是介绍一个编译好的lapack二进制包ACML(AMD Core Math Library),并 ...

  8. This application failed to start because it could not find or load the Qt platform plugin "xcb".

    1.  copy      libQt5DBus.so.5 2.  add    QT_PLUGIN_PATH blog.csdn.net/windows_nt/article/details/242 ...

  9. [收藏]Asp.net MVC生命周期

    一个HTTP请求从IIS移交到Asp.net运行时,Asp.net MVC是在什么时机获得了控制权并对请求进行处理呢?处理过程又是怎样的? 以IIS7中asp.net应用程序生命周期为例,下图是来自M ...

  10. C语言解析json类型数据

    转自:http://buluzhai.iteye.com/blog/845404   首先感谢作者!! 我使用的是cJSON:http://sourceforge.net/projects/cjson ...