当前位置: 代码迷 >> 综合 >> 白话并发冲突与线程同步(2)——Monitor、lock和死锁
  详细解决方案

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

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


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,两个线程双双陷入阻塞状态,直到山无棱、天地合…… 这就是死锁
  相关解决方案