c# lock 锁

• lock语句

lock 语句获取给定对象的互斥 lock，执行语句块，然后释放 lock。 持有 lock 时，持有 lock 的线程可以再次获取并释放 lock。 阻止任何其他线程获取 lock 并等待释放 lock。

• 为什么需要锁

作为C#的程序员来说，在遇到线程同步的需求时最常用的就是lock关键字。lock 的目的很明确，就是不想让别人使用这段代码，体现在多线程情况下，只允许当前线程执行该代码区域，其他线程等待直到该线程执行结束；这样可以多线程避免同时使用某一方法造成数据混乱。

• lock的等效代码

在.NET的多线程程序中，经常会遇到lock关键字来控制同步，比如下列代码：

private object o = new object();

public void Work()

{

　　lock(o)

　　{

　　　　//做一些需要线程同步的工作

　　}

}

事实上，lock这个关键字是C#为方便程序员而定义的语法，它等效于安全地使用System.Threading.Monitor类型。上面的代码就直接等效于下面的代码：

private object o = new object();

public void Work()

{

　　//这里很重要，是为了避免直接使用私有成员o，而导致线程不安全

　　object temp = o;

　　System.Threading.Monitor.Enter(temp);

　　try

　　{

　　　　//做一些需要线程同步的工作

　　}

　　finally

　　{

　　　　System.Threading.Monitor.Exit(temp);

　　}

}

 正如你看到的，真正实现了线程同步功能的，就是System.Threading.Monitor类型，lock关键字只是用来代替调用Enter、Exit方法，并且将所有的工作包含在try块内，以保证其最终退出同步。

注意：我们lock的一般是对象，不是值类型和字符串。

1、为什么不能lock值类型

    比如lock(1)呢?lock本质上Monitor.Enter，Monitor.Enter会使值类型装箱，每次lock的是装箱后的对象。lock 其实是类似编译器的语法糖，因此编译器直接限制住不能lock值类型。退一万步说，就算能编译器允许你lock(1)，但是 object.ReferenceEquals(1,1)始终返回false(因为每次装箱后都是不同对象),也就是说每次都会判断成未申请互斥锁，这样 在同一时间，别的线程照样能够访问里面的代码，达不到同步的效果。同理lock((object)1)也不行。

 2、Lock字符串

    那么lock("xxx")字符串呢?MSDN上的原话是：

锁定字符串尤其危险，因为字符串被公共语言运行库 (CLR)“暂留”。 这意味着整个程序中任何给定字符串都只有一个实例，同一个对象表示了所有运行的应用程序域的所有线程中的该文本。因此，只要在应用程序进程中的任何 位置处具有相同内容的字符串上放置了锁，就将锁定应用程序中该字符串的所有实例。

 3、MSDN推荐的Lock对象

    通常，最好避免锁定 public 类型或锁定不受应用程序控制的对象实例。例如，如果该实例可以被公开访问，则 lock(this) 可能会有问题，因为不受控制的代码也可能会锁定该对象。这可能导致死锁，即两个或更多个线程等待释放同一对象。出于同样的原因，锁定公共数据类型(相比于 对象)也可能导致问题。

    而且lock(this)只对当前对象有效，如果多个对象之间就达不到同步的效果。

    而自定义类推荐用私有的只读静态对象，比如：

private static readonly object obj = new object();

为什么要设置成只读的呢?这是因为如果在lock代码段中改变obj的值，其它线程就畅通无阻了，因为互斥锁的对象变了，object.ReferenceEquals必然返回false。

•  Lock 关键字锁定静态变量和非静态变量的区别

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace testLock
{
    class Program
    { 
        static void Main(string[] args)
        { 
            Console.WriteLine("----------开始测试单实例非静态锁----------");

            MyLock myLock = new MyLock(); 
            for (int i = 0; i < 5; i++)
            {
                Thread t = new Thread(myLock.Increment1); 
                t.Start(); 
            } 

            Thread.Sleep(3 * 1000);

            Console.WriteLine("----------开始测试单实例静态锁----------");

            MyLock myLock2 = new MyLock(); 
            for (int i = 0; i < 5; i++)
            {  
                Thread t = new Thread(myLock2.Increment2); 
                t.Start(); 
            } 

            Thread.Sleep(3 * 1000); 

            Console.WriteLine("----------开始测试多实例非静态锁----------");
             

            for (int i = 0; i < 5; i++)
            {
                MyLock mlock = new MyLock();
                Thread t = new Thread(mlock.Increment1); 
                t.Start(); 
            }  

            Thread.Sleep(3 * 1000); 

            Console.WriteLine("----------开始测试多实例静态锁----------"); 

            for (int i = 0; i < 5; i++)
            {
                MyLock mlock = new MyLock();
                Thread t = new Thread(mlock.Increment2); 
                t.Start(); 
            }
 

            Console.Read();

        }
    } 

    public class MyLock
    {
        //静态变量锁对象
        private readonly static object staticObj = new object();

        //非静态变量锁对象
        private readonly object obj = new object();

        //成员变量 
        private static int i1 = 0; 
        private static int i2 = 0;


        /// <summary>
        /// 非静态锁
        /// </summary>
        /// <param name="handleObject">要处理的对象</param>
        public  void Increment1(object handleObject)
        { 
            lock (obj)
            { 

                Console.WriteLine("i1的值为：{0}", i1);

                //这里刻意制造线程并行机会，来检查同步的功能

                Thread.Sleep(200);

                i1++;

                Console.WriteLine("i1自增后为：{0}", i1);

            } 
        }

        /// <summary>
        /// 静态锁
        /// </summary>
        /// <param name="handleObject">要处理的对象</param>
        public void Increment2(object handleObject)
        { 
            lock (staticObj)
            {

                Console.WriteLine("i2的值为：{0}", i2);

                //这里刻意制造线程并行机会，来检查同步的功能

                Thread.Sleep(200);

                i2++;

                Console.WriteLine("i2自增后为：{0}", i2);

            } 
        } 
        
    }
}

单实例非静态锁，线程没有并发（加锁成功）；

单实例静态锁，线程没有并发（加锁成功）；

多实例非静态锁，线程并发（加锁失败）；

多实例静态锁，线程没有并发（加锁成功）

说明：以上内容是根据网上内容进行整理，并加以归纳。