白话并发冲突与线程同步(2)——Monitor、lock和死锁

转载 2012年06月01日 17:32:45
     竞赛暂时胜过它的目的,永远如此。对于要建立殖民地的殖民主义者,生活的意义就在于征服。士兵看不起移民,但是,征服的目的不就是要让移民定居下来吗?因此,在进步的狂热中,我们把人招来修铁路,建工厂,钻油井。但是,我们不是记得很清楚,我们进行的这些建设是服务人类的。……真理,对于一些人来说就是建造房子,而对于另一些人来说就是居住。
                                                                                    ——圣埃克絮佩里
                                                                                          摘自《人的大地》


1-2-3 和比尔盖茨的一些往事

在上一篇里我们说道,1-2-3写了一段程序,并且在使用了2个线程分别执行foo1()和foo2()之后,程序的结果就不对了。

class Program
{
   
 static int n = 0
;
   
 static void
 foo1()
    {
       
 for (int i = 0; i < 1000000000; i++) //
 10 浜?/span> 
        {
               
 int a =
 n;
                n
 = a + 1
;
        }
        Console.WriteLine(
"foo1() complete n = {0}"
, n);
    }
   
 static void
 foo2()
    {
       
 for (int j = 0; j < 1000000000; j++) //
 10 浜?/span> 
        {
               
 int a =
 n;
                n
 = a + 1
;
        }
        Console.WriteLine(
"foo2() complete n = {0}"
, n);
    }
   
 static void Main(string
[] args)
    {
       
 new Thread
(foo1).Start();
       
 new Thread
(foo2).Start();
    }
}

究其原因,就是因为Windows总是不问青红皂白随随便便就把我的线程给停掉了。例如,上面的那个程序很可能会以下面的顺序来执行(黄色底色的代码属于第一个线程,绿色底色的代码属于第二个线程):


这样,第一、第二个线程里面的循环各自执行了3次,n的值是3,而不是我们期望的6。
所以呢,我就打算建议比尔盖茨在C#里加一个关键字:

对foo2()也做同样的修改,这样,就可以确保程序以下图所示的顺序执行了:


如果这个建议被微软接受,它将创造两个记录:
  1. 它将是C#里面第一个中文关键字。
  2. 它将是C#里面最长的关键字。

可是,比尔盖茨听了我的建议之后,却把眉毛皱成了个大疙瘩,叹道:“大哥,不行呀。你知道,Windows里会同时运行着上千个线程,且不说那些居心不良的病毒和木马,就是那些干正经事的线程,谁又能保证在你那个超长关键字里包裹的代码不会运行个二、三十秒?CPU可只有一个,在那个线程运行的二、三十秒里,整个Windows都会一动不动的,不知情的用户还以为是Windows又挂掉了,最后挨骂的可是兄弟我呦!”

“不过,”比尔又接着说,“我可以提供另一种方案来达到同样的效果。我可以让线程1里面的指定代码块不执行完,线程2就一直处于阻塞(ThreadState.WaitSleepJoin)状态。”

要达到这个效果,需要使用.net里的两个函数。

Monitor.Enter(n); // 尝试获取对n的控制权。如果n没主儿,则成功获取了n的控制权;如果n已经有主儿了,则此线程阻塞,死等。
Monitor.Exit(n); // 释放对n的控制权。等待着n的那个阻塞中的线程将获取n的控制权,并从阻塞状态变成运行状态。

可以把n想像成WC里的一个蹲位,线程1 Enter了之后,其它线程就不能Enter了,只能干等着,直到线程1 Exit,下一个等着的线程才能Enter,之后才能继续办事。如果一个线程Enter了之后迟迟不Exit(例如Enter了之后,发生了异常,比如忘了带SZ),就是所谓的“占着MK不LS”了。(一边吃午饭一边看贴的兄弟对不住啦~~)

使用 Monitor

现在就可以在我的代码里使用Monitor了。

class Program
{
   
 static int n = 0
;
   
 static void
 foo1()
    {
       
 for (int i = 0; i < 1000000000; i++) // 10 亿
 
        {
            Monitor.Enter(n);
           
 int a =
 n;
            n
 = a + 1
;
            Monitor.Exit(n);
        }
        Console.WriteLine(
"foo1() complete n = {0}"
, n);
    }

   
 static void
 foo2()
    {
       
 for (int j = 0; j < 1000000000; j++) // 10 亿
 
        {
           
 Monitor.Enter(n);
           
 int a = n;
            n
 = a + 1
;
           
 Monitor.Exit(n);
        }
        Console.WriteLine(
"foo2() complete n = {0}", n);
    }
   
 static void Main(string
[] args)
    {
       
 new
 Thread(foo1).Start();
       
 new
 Thread(foo2).Start();
    }
}

这段代码很可能会以下图所示的顺序执行(黄色底色的代码属于线程1,绿色底色的代码属于线程2。下图演示了线程1循环2次,线程2循环1次,n的值为3):


如果我们把上图之中与Monitor相关的行和演示线程状态的行去掉,就可以得到下图:


怎么样?和我的那个超长关键字的效果一样吧?

不过,如果你尝试运行上面那个代码,就会发现它根本无法通过编译!这是因为Monitor.Enter()只接受类型为Object的参数。那么,可不可以写 Monitor.Enter(
(Object)n); 呢?它确实能够通过编译,但是这样岂不是要装箱20亿次?所以千万别这么写。没法子了,我们只能再声明一个Object类型的变量,专门用于这两个线程的同步。
class Program
{
   
 static int n = 0
;
   
 static object mk = new object();
 
   
 static void foo1()
    {
       
 for (int i = 0; i < 1000000000; i++) // 10 亿
 
        {
            Monitor.Enter(mk);
           
 int a =
 n;
            n
 = a + 1
;
            Monitor.Exit(mk);
        }
        Console.WriteLine(
"foo1() complete n = {0}"
, n);
    }
   
 static void
 foo2()
    {
       
 for (int j = 0; j < 1000000000; j++) // 10 亿
 
        {
            Monitor.Enter(mk);
           
 int a =
 n;
            n
 = a + 1
;
            Monitor.Exit(mk);
        }
        Console.WriteLine(
"foo2() complete n = {0}"
, n);
    }
   
 static void Main(string
[] args)
    {
       
 new
 Thread(foo1).Start();
       
 new
 Thread(foo2).Start();
    }
}

这段代码在我的赛扬800的机器上运行时间为3分零6秒。

lock 关键字

在C#里面有一个lock关键字,它其实是一个语法糖。

小贴士:在VB里与lock等价的关键字是SyncLock。用法是

SyncLock (mk)
   
 Dim a As Integer =
 n
    n
 = a + 1
 
End SyncLock

死锁 

还有比占着MK不LS更恶劣的行径么?有,那就是吃着碗里的望着锅里的。在下面的这段代码中,线程1喜欢先占着mk1然后在mk2里办事;线程2呢,喜欢先占着mk2,然后在mk1里办事,要是这两个活宝碰到一起……

class Program
{
   
 static object mk1 = new object
();
   
 static object mk2 = new object
();
   
 static void
 foo1()
    {
       
 for (int i = 0; i < 100; i++
)
        {
            Monitor.Enter(mk1);
            Console.WriteLine(
"i={0} 线程1:\"先占着mk1,再去mk2里办事。\""
, i);
            Monitor.Enter(mk2);
            Console.WriteLine(
"i={0} 线程1:\"进入了mk2,办事\""
, i);
            Monitor.Exit(mk2);
            Console.WriteLine(
"i={0} 线程1:\"办完事了,离开mk2\""
, i);
            Monitor.Exit(mk1);
            Console.WriteLine(
"i={0} 线程1:\"办完事了,离开mk1\""
, i);
        }
    }
   
 static void
 foo2()
    {
       
 for (int j = 0; j < 100; j++
)
        {
            Monitor.Enter(mk2);
            Console.WriteLine(
"j={0} 线程2:\"先占着mk2,再去mk1里办事。\""
, j);
            Monitor.Enter(mk1);
            Console.WriteLine(
"j={0} 线程2:\"进入了mk1,办事\""
, j);
            Monitor.Exit(mk1);
            Console.WriteLine(
"j={0} 线程2:\"办完事了,离开mk1\""
, j);
            Monitor.Exit(mk2);
            Console.WriteLine(
"j={0} 线程2:\"办完事了,离开mk2\""
, j);
        }
    }
   
 static void Main(string
[] args)
    {
       
 new
 Thread(foo1).Start();
       
 new
 Thread(foo2).Start();
    }
}

运行这段代码,可以得到这样的结果:


如上图所示,当程序恰巧以“线程1 Enter mk1 -> 线程2 Enter mk2 -> 线程1 想要Enter mk2 发现 mk2 已经被占用,线程1阻塞 -> 线程2 想要Enter mk1 发现 mk1 己经被占用,线程2阻塞”这个顺序执行时,线程1等待线程2释放mk2,线程2等待线程1释放mk1,两个线程双双陷入阻塞状态,直到山无棱、天地合…… 这就是死锁

相关文章推荐

白话并发冲突与线程同步(3)——Mutex、EventWaitHandle、AutoResetEvent 和 Manua (2012-05-18 13:16:12)

转载▼      不过这热气是从实在的火里发出来的呢,还是从他的爱情里发出来的呢,他完全不知道。他的一切光彩现在都没有了。这是因为他在旅途中失去了呢,还是悲愁的结果,谁也说不出来。 ...

C#线程同步——lock,Monitor,Mutex

线程:线程是进程的独立执行单元,每一个进程都有一个主线程,除了主线程可以包含其他的线程。多线程的意义:多线程有助于改善程序的总体响应性,提高CPU的效率。      多线程的应用程序域是相当不稳定的,...

线程同步锁lock(object) 与Monitor.enter(object)的使用

using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.T...
  • Joyhen
  • Joyhen
  • 2014年04月02日 09:55
  • 1471

白话并发冲突与线程同步(1)

转载▼     猴子抬头道:“我有一个梦,我想我飞起时,那天也让开路,我入海时,水也分成两边,众仙诸神,见我也称兄弟,无忧无虑,天下再无可拘我之物,再无可管我之人,再无我到不了之处,...

C#笔记21:多线程之线程同步中的锁定lock、Monitor

作者:Luminji 转自:http://www.cnblogs.com/luminji/archive/2010/09/17/1829380.html C#笔记21:多线程之线程同步中的锁定l...
  • whw8007
  • whw8007
  • 2014年03月25日 19:54
  • 407

[C#学习笔记之多线程2]多线程同步与并发访问共享资源工具—Lock、Monitor、Mutex、Semaphore

“线程同步”的含义         当一个进程启动了多个线程时,如果需要控制这些线程的推进顺序(比如A线程必须等待B和C线程执行完毕之后才能继续执行),则称这些线程需要进行“线程同步(thr...

c# 线程同步系列(一)lock与Monitor的用法

http://hillstone.blog.hexun.com/51036044_d.htmllock(x){  DoSomething();}这等效于:System.Object obj = (Sy...

多线程:C#线程同步lock,Monitor,Mutex,同步事件和等待句柄(上)

转自 http://www.cnblogs.com/freshman0216/archive/2008/07/27/1252253.html  本篇从Monitor,Mutex,ManualReset...

多线程:C#线程同步lock,Monitor,Mutex,同步事件和等待句柄(上)

转自:http://www.cnblogs.com/freshman0216/archive/2008/07/29/1252253.html 本篇从Monitor,Mutex,ManualR...

多线程:C#线程同步lock,Monitor,Mutex,同步事件和等待句柄(下)

同系列阅读:多线程:C#线程同步lock,Monitor,Mutex,同步事件和等待句柄(上),多线程:C#线程同步lock,Monitor,Mutex,同步事件和等待句柄(中)       前两篇...
  • Baple
  • Baple
  • 2012年01月05日 09:25
  • 724
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:白话并发冲突与线程同步(2)——Monitor、lock和死锁
举报原因:
原因补充:

(最多只允许输入30个字)