Question

如何实现多线程并发控制？

如何实现多线程并发控制？

若以下回答无法解决问题，邀请你更新回答

Answer 1

C#提供了一个lock关键字，它可以把一段代码定义为互斥段（critical section），互斥段在一个时刻内只允许一个线程进入执行，而其他线程必须等待。在C#中，C# lock关键字定义如下：

lock(expression) statement_block

expression代表你希望跟踪的对象，通常是对象引用。
如果你想保护一个类的实例，一般地，你可以使用this；
如果你想保护一个静态变量（如互斥代码段在一个静态方法内部），一般使用类名就可以了。

而statement_block就做答是互斥段的代码，这郑陆段代码在一个时刻内只可能被一个线程执行。

下面是一个使用C# lock关键字的典型例子，在注释里说明了C# lock关键字的用法和用途。

示例如下：

1. using System;
2. using System.Threading;
3.
4. namespace ThreadSimple
5. {
6. internal class Account
7. {
8. int balance;
9. Random r = new Random();
10.
11. internal Account(int initial)
12. {
13. balance = initial;
14. }
15. internal int Withdraw(int amount)
16. {
17. if (balance < 0)
18. {
19. //如果balance小于0则抛出异常
20. throw new Exception("Negative Balance");
21. }
22. //下面的代码保证在当前线程修改balance的值完成之前
23. //不会有其他线程也执行这段代码来修改balance的值
24. //因此，balance的值是不可能小于0 的
25. lock (this)
26. {
27. Console.WriteLine("Current Thread:"+Thread.CurrentThread.Name);
28. //如果没有lock关键字的保护，那么可能在执行完if的条件判断之后
29. //另外一个线程却执行了balancebalance=balance-amount修改了balance的值
30. //而这个修改对这个线程喊胡顷是不可见的，所以可能导致这时if的条件已经不成立了
31. //但是，这个线程却继续执行balancebalance=balance-amount，所以导致balance可能小于0
32. if (balance >= amount)
33. {
34. Thread.Sleep(5);
35. balancebalance = balance - amount;
36. return amount;
37. }
38. else
39. {
40. return 0; // transaction rejected
41. }
42. }
43. }
44. internal void DoTransactions()
45. {
46. for (int i = 0; i < 100; i++)
47. Withdraw(r.Next(-50, 100));
48. }
49. }
50. internal class Test
51. {
52. static internal Thread[] threads = new Thread[10];
53. public static void Main()
54. {
55. Account acc = new Account (0);
56. for (int i = 0; i < 10; i++)
57. {
58. Thread t = new Thread(new ThreadStart(acc.DoTransactions));
59. threads[i] = t;
60. }
61. for (int i = 0; i < 10; i++)
62. threads[i].Name=i.ToString();
63. for (int i = 0; i < 10; i++)
64. threads[i].Start();
65. Console.ReadLine();
66. }
67. }
68. }

Monitor 类锁定一个对象

当多线程公用一个对象时，也会出现和公用代码类似的问题，这种问题就不应该使用C# lock关键字了，这里需要用到System.Threading中的一个类Monitor，我们可以称之为监视器，Monitor提供了使线程共享资源的方案。

Monitor类可以锁定一个对象，一个线程只有得到这把锁才可以对该对象进行操作。对象锁机制保证了在可能引起混乱的情况下一个时刻只有一个线程可以访问这个对象。 Monitor必须和一个具体的对象相关联，但是由于它是一个静态的类，所以不能使用它来定义对象，而且它的所有方法都是静态的，不能使用对象来引用。下面代码说明了使用Monitor锁定一个对象的情形：

1. ......
2.
3. Queue oQueue=new Queue();
4.
5. ......
6.
7. Monitor.Enter(oQueue);
8.
9. ......//现在oQueue对象只能被当前线程操纵了
10.
11. Monitor.Exit(oQueue);//释放锁

如上所示，当一个线程调用Monitor.Enter()方法锁定一个对象时，这个对象就归它所有了，其它线程想要访问这个对象，只有等待它使用 Monitor.Exit()方法释放锁。为了保证线程最终都能释放锁，你可以把Monitor.Exit()方法写在try-catch- finally结构中的finally代码块里。