由单例模式学到：lock锁
lock 关键字将语句块标记为临界区，方法是获取给定对象的互斥锁，执行语句，然后释放该锁。
lock (xxx)
{
// Critical code section.
}
lock 关键字可确保当一个线程位于代码的临界区时，另一个线程不会进入该临界区。 如果其他线程试图进入锁定的代码，则它将一直等待（即被阻止），直到该对象被释放。
用实例说话：
例1
新建多个线程，用多个线程的操作来模拟实现lock的场景
public static void fun()
{
Thread[] threads = new Thread[500];
User u = new User();
for (int i = 0; i < 50; i++)
{
threads[i] = new Thread(new ParameterizedThreadStart(getInstance));
threads[i].IsBackground = true;
threads[i].Start(u);
}
}
以上新建了50个线程，并且让每个线程都执行getInstance方法，并且每个getInstance方法的参数为User的实例upublic static void getInstance(object obj)
{
User u = (User)obj;
Console.WriteLine(u.addtion());
}以上代码段执行User类的addtion方法，并得到返回值。即：此时有50个线程在执行同一个User实例的u的addtion方法，在执行addtion方法的时候，addtion方法中的lock(this)起到锁的作用，当第一个线程进入lock代码块中后，将会把其他的线程阻塞到外面，直到第一个线程执行完，锁得到释放，其他线程中的一个才得以执行。
public class User
{private static int sin;
public string addtion()
{
lock (this)
{
sin = sin + 10;
Thread.Sleep(50);
return sin.ToString();
}
}
}
如上的代码，如果lock(this)起到锁的作用的话，线程一个一个执行，每个线程的执行sin的值都会增加10。期望的效果为：10，20，30，40，50....
=====执行的效果为
：注意上述代码中的红色字体标记的部分，多个线程执行的都是同一个User实例的addtion方法，所以lock(this)起到了锁了作用，如果让每个线程都实例化一个User类，再去执行自己实例化的User类的addtion方法，那么lock(this)就起不到作用了！
即：public static void fun()
{
Thread[] threads = new Thread[500];
for (int i = 0; i < 50; i++)
{
threads[i] = new Thread(new ParameterizedThreadStart(getInstance));
threads[i].IsBackground = true;
threads[i].Start(i);
}
}
public static void getInstance(object obj)
{
User u = new User();
Console.WriteLine(u.addtion());
}如果是上述代码的话，则lock就锁不住，lock块中可能有多个线程在执行，即：如果第一个线程把sin设置为10，再第一个线程还没有结束之前，第二个线程会再将sin加10，如此循环，n个线程执行之后，那么第一个线程执行结束后，sin的值就变成了n*10。
执行效果为：
实例中还涉及到静态字段，静态字段在IL中标记为BeforeFieldInit，即：静态字段是由程序自动执行，与普通字段不同的是，它仅执行一次，在之后类的实例化时，也不需要再此执行。从而上述代码中sin的字段才得以保存。如果sin字段的static去掉的话，则输出的就是：10，10，10，10....
由此即可得到结论：lock(this) 锁定 当前实例对象，如果有多个类实例的话，lock锁定的只是当前类实例，对其它类实例无影响。
lock中的this表示的是当前实例，对于同一个实例的多线程来说，当第一个现成进来的时，通过lock(this)将当前实例上锁，那么当此实例的其他线程进来的时候，该实例已经上锁，所以就不能进入；而对于每个线程都实例化一个对象就不一样了，当第一个线程进来的时候，lock将第一个线程的实例上锁，那么之后所有的第一个线程实例化的对象就不能再进入访问，这里仅仅是对第一个线程实例化的对象，如果是除此之外的所有其他的对象的话，是起不到锁的作用，即:当第二个线程、第三个线程、、等，到达lock时，是不被锁上的！
例2
既然lock(this)只能防止当前实例多线程访问，不能防止其他实例进入！对于上述的内容如果了解之后，不难想到如何做到绝对防止其他线程(无论是什么实例)进入lock的逻辑块，其实就来实例化一个任意的对象(静态的)，例如：private static object obj=new object();lock(obj);因为静态的对象只是由程序自动执行一次，之后再实例化时，用得还是原来的，下面就来说一下访问流程，新建n个任意实例的线程，当第一个线程进来时，利用lock将obj上锁，第一个线程进入lock逻辑块中执行，当第二个、第三个等线程进来时，因为obj是静态的对象，所有obj的值还是第一线程给设置的状态，即：是上锁的。所以其他线程是无法进入的。
public class User
{
private static object obj = new object();
private static int sin = 0;
public string addtion()
{
lock (obj)
{
sin = sin + 10;
Thread.Sleep(500);
return sin.ToString();
}
}
}注意：1.必须是静态字段。不然的话，每次对象的实例化时都会执行一次object obj = new object() ，那么obj每次都是新实例化的对象，其状态肯定是没有上锁的，那样的话就无法起到对任意类型进行锁的操作；2.这里用了objct对象，其实其他对象也是可以的，例如：privatestatic List<User> obj = new List<User>(); 也是可以的，lock的参数其实就是一个变量，当有线程进入的时候，将变量的状态设置为锁，当其他线程到达时，读取到变量的状态如果是锁的，那么就等待，如果不是锁的，那么就进入lock代码块去执行；3.lock的参数其实就是充当变量，当第一个线程到达时候，将其设置为锁状态，当此线程执行完lock代码块中的逻辑后，再将此变量设置成未锁状态！至于上述例子中讨论的不同情况，就是变量如何取值的问题了。
MSDN上说：
通常，应避免锁定 public 类型，否则实例将超出代码的控制范围。 常见的结构 lock (this)、lock (typeof (MyType)) 和 lock ("myLock")违反此准则：
如果实例可以被公共访问，将出现 lock (this) 问题。
如果 MyType 可以被公共访问，将出现 lock (typeof (MyType)) 问题。
由于进程中使用同一字符串的任何其他代码都将共享同一个锁，所以出现 lock("myLock") 问题。
最佳做法是定义 private 对象来锁定, 或 private static 对象变量来保护所有实例所共有的数据。
===分析上述的说法：lock(this)出现的问题指的是：lock(this)只对本实例进行锁，其他实例的话就起不到锁的效果，因为lock(this)是将本实例的状态设置为锁，其他实例到达时，this又是值得自己的实例，而不是上次设置为锁的实例，所有就起不到锁的效果了；lock(typeof(MyType))出现的问题是指：他可以对MyType类型的所有实例进行锁的效，果。因为lock(MyType)是将此对象的状态设置为锁，而所有MyType类的实例化都是一个对象MyType，所以他就可以起到对所有实例的锁的效果。虽然其从效果上达到了要求，但是微软现在建议不要使用 lock(typeof(MyType)),因为锁定类型对象是个很缓慢的过程，并且类中的其他线程、甚至在同一个应用程序域中运行的其他程序都可以访问 该类型对象，因此，它们就有可能代替您锁定类型对象，完全阻止您的执行，从而导致你自己的代码的挂起(红色字体表示看不懂)；lock("myLock")出现的问题指的是：因为string是引用类型，如果多个变量的值为“myLock”，那么如果lock("myLock")之后，就是将“myLock”的状态设置为锁，那么在栈中的变量名都指向在堆中的“myLock”，即：当前都是锁的状态了，如果其中一个变量名为str1，那么存在lock("myLock")的同时也存在lock(str1)，将两个lock设置在两个方法中，并且新建n个线程来执行此两个方法，就会出现当有一个线程执行lock("myLock")之后，lock(str1)的代码块也上锁了。
例：lock("myLock")static void Main(string[] args) { Thread[] threads = new Thread[500]; for (int i = 0; i < 50; i=i+2) { threads[i] = new Thread(new ParameterizedThreadStart(fun1)); threads[i+1] = new Thread(new ParameterizedThreadStart(fun2)); threads[i].IsBackground = true; threads[i+1].IsBackground = true; threads[i].Start(null); threads[i+1].Start(null); } Console.ReadKey(); } public static void fun1(object obj) { User u = new User(); Console.WriteLine("fun1: "+u.addtion1()); } public static void fun2(object obj) { User u = new User(); Console.WriteLine("fun2:"+u.addtion2()); }public class User { private static object obj = new object(); private static string str1 = "123"; private static int sin1 = 0; private static int sin2 = 1000; public string addtion1() { lock ("123") { sin1 = sin1 + 10; Thread.Sleep(100); return sin1.ToString() + "-" + DateTime.Now.Ticks.ToString(); } } public string addtion2() { lock (str1) { sin2 = sin2 + 10; Thread.Sleep(100); return sin2.ToString() + "-" + DateTime.Now.Ticks.ToString(); } } } 打上断点，调试看就可看出。当线程在lock ("123")中执行时，即使到了Thread.Sleep(100);也会等待，然后再继续执行，这就说明此时lock (str1)也是锁的状态！这就是问题所在！ public class User { private static object obj = new object(); private static string str1 = "12345"; private static int sin1 = 0; private static int sin2 = 1000; public string addtion1() { lock ("123") { sin1 = sin1 + 10; Thread.Sleep(100); return sin1.ToString() + "-" + DateTime.Now.Ticks.ToString(); } } public string addtion2() { lock (str1) { sin2 = sin2 + 10; Thread.Sleep(100); return sin2.ToString() + "-" + DateTime.Now.Ticks.ToString(); } } }
打上断点调试看，当线程在lock ("123")中执行时，当到达Thread.Sleep(100)时，lock (str1)中的代码就会执行，这说明此时lock (str1)的状态是未上锁。实际上两个方法是同时执行的，只不过是因为打上了断电，才造成只能看到一步一步的操作！
