白话并发冲突与线程同步(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,两个线程双双陷入阻塞状态,直到山无棱、天地合…… 这就是死锁

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

竞赛暂时胜过它的目的,永远如此。对于要建立殖民地的殖民主义者,生活的意义就在于征服。士兵看不起移民,但是,征服的目的不就是要让移民定居下来吗?因此,在进步的狂热中,我们把人招来修铁路,建工厂,钻油井。...
  • aspgreener
  • aspgreener
  • 2008-06-10 09:17:00
  • 270

VB.net学习笔记(二十七)线程同步上

X夫妇二人试图同时从同一账户(总额1000)中支取1000。由于余额有1000,夫妇各自都满足条件,于是银行共支付2000。结果是银行亏了1000元。这种两个或更多线程试图在同一时刻访问同一资源来修改...
  • dzweather
  • dzweather
  • 2016-06-11 10:58:04
  • 4009

并发插入引发的死锁问题排查

一.业务背景我们现在的业务是一款数据产品,有不少实时计算和爬取来的数据都汇总到大数据仓库、数据挖掘平台ODPS上。然后应用在读取这些数据时,这些数据会先导入到并发读能力更强,适合结构查询的mysql上...
  • qq_16681169
  • qq_16681169
  • 2017-06-16 23:52:38
  • 2226

死锁的三种形式:一般死锁,嵌套管程锁死,重入锁死

死锁的总结 死锁的定义: 死锁一般是指两个(或两个以上)线程同时竞争两个(或者多个)资源,从而产生同时等待的现象,使得系统僵持不动。 顺便复习一下线程与进程的定义以及他们之间的区别。 进程:一...
  • oChenXiaoZuo1
  • oChenXiaoZuo1
  • 2014-07-28 21:15:40
  • 1964

C#_线程同步介绍

  • 2012年03月01日 10:15
  • 318KB
  • 下载

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

白话并发冲突与线程同步(1)     猴子抬头道:“我有一个梦,我想我飞起时,那天也让开路,我入海时,水也分成两边,众仙诸神,见我也称兄弟,无忧无虑,天下再无可拘我之物,再无可管我之人,再无我到不了之...
  • aspgreener
  • aspgreener
  • 2008-06-10 09:19:00
  • 337

Log4j1.2 --- 死锁

log4j 死锁
  • FuXiaoZhuan
  • FuXiaoZhuan
  • 2010-10-10 16:28:00
  • 9863

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

猴子抬头道:“我有一个梦,我想我飞起时,那天也让开路,我入海时,水也分成两边,众仙诸神,见我也称兄弟,无忧无虑,天下再无可拘我之物,再无可管我之人,再无我到不了之处,再无我做不成之事,再无我战不胜之物...
  • ulark
  • ulark
  • 2010-01-02 20:18:00
  • 318

Monitor实例--tryenter解除死锁

在多线程编程里面,经常出现的两个问题:一个是共享资源(异步之后的同步),另外一个是死锁。用到lock和monitor .enter(obj)进行资源同步时,如果控制不好如意出现死锁现象:lock(A)...
  • Folish_Audi
  • Folish_Audi
  • 2014-07-03 10:28:21
  • 1530

PostgreSQL高并发单行更新发生死锁 2015

这么简单的一条SQL,100个并发时居然会发生死锁,太不可思议了。 发生死锁的SQL update_smallrange.sql: \setrandom id 1 10000 ...
  • baidu_18607183
  • baidu_18607183
  • 2015-10-24 10:09:42
  • 1206
收藏助手
不良信息举报
您举报文章:白话并发冲突与线程同步(2)——Monitor、lock和死锁
举报原因:
原因补充:

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