关于Lock总结

 (一)　lock 关键字
        可以用来确保代码块完成运行，而不会被其他线程中断。这是通过在代码块运行期间为给定对象获取互斥锁来实现的。
   （二）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("xxx")字符串呢？
       因为字符串被公共语言运行库 (CLR)“暂留”。 这意味着整个程序中任何给定字符串都只有一个实例，就是这同一个对象表示了所有运行的应用程序域的所有线程中的该文本。
       因此，只要在应用程序进程中的任何位置处具有相同内容的字符串上放置了锁，就将锁定应用程序中该字符串的所有实例。
    (4)通常，最好避免锁定 public 类型或锁定不受应用程序控制的对象实例。例如，如果该实例可以被公开访问，则 lock(this) 可能会有问题，因为不受控制的代码也可能会锁定该对象。这可能导致死锁，即两个或更多个线程等待释放同一对象。出于同样的原因，锁定公共数据类型（相比于对象）也可能导致问题。而且lock(this)只对当前对象有效，如果多个对象之间就达不到同步的效果。
　　(5)lock(typeof(Class))与锁定字符串一样，范围太广了。某些系统类提供专门用于锁定的成员。例如，Array 类型提供 SyncRoot。许多集合类型也提供 SyncRoot。
    (6)自定义类推荐用私有的只读静态对象，比如：private static readonly object obj = new object();
     为什么要设置成只读的呢？这时因为如果在lock代码段中改变obj的值，其它线程就畅通无阻了，因为互斥锁的对象变了，object.ReferenceEquals必然返回false。
    (三)自己的理解
      lock对象并不是要针对你的要操作的对象进行锁，可以重新定义一个Object obj对象来作为所对象。
      例如你操纵List list=new List();并不是需要你lock(list)。可以用lock(obj)

using System;
using System.Threading;
/*
    (一)　lock 关键字
        可以用来确保代码块完成运行，而不会被其他线程中断。这是通过在代码块运行期间为给定对象获取互斥锁来实现的。
   （二）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("xxx")字符串呢？
       因为字符串被公共语言运行库 (CLR)“暂留”。 这意味着整个程序中任何给定字符串都只有一个实例，就是这同一个对象表示了所有运行的应用程序域的所有线程中的该文本。
       因此，只要在应用程序进程中的任何位置处具有相同内容的字符串上放置了锁，就将锁定应用程序中该字符串的所有实例。
    (4)通常，最好避免锁定 public 类型或锁定不受应用程序控制的对象实例。例如，如果该实例可以被公开访问，则 lock(this) 可能会有问题，因为不受控制的代码也可能会锁定该对象。这可能导致死锁，即两个或更多个线程等待释放同一对象。出于同样的原因，锁定公共数据类型（相比于对象）也可能导致问题。而且lock(this)只对当前对象有效，如果多个对象之间就达不到同步的效果。
　　(5)lock(typeof(Class))与锁定字符串一样，范围太广了。某些系统类提供专门用于锁定的成员。例如，Array 类型提供 SyncRoot。许多集合类型也提供 SyncRoot。
    (6)自定义类推荐用私有的只读静态对象，比如：private static readonly object obj = new object();
     为什么要设置成只读的呢？这时因为如果在lock代码段中改变obj的值，其它线程就畅通无阻了，因为互斥锁的对象变了，object.ReferenceEquals必然返回false。
    (三)自己的理解
      lock对象并不是要针对你的要操作的对象进行锁，可以重新定义一个Object obj对象来作为所对象。
      例如你操纵List list=new List();并不是需要你lock(list)。可以用lock(obj)
 */

class Account
{
    private Object thisLock = new Object();//所对象
    int balance;//余额
    Random r = new Random();
    public Account(int initial)
    {
        balance = initial;
    }

    int Withdraw(int amount)
    {

        // This condition will never be true unless the lock statement
        // is commented out:
        if (balance < 0)
        {
            throw new Exception("Negative Balance");
        }

        // Comment out the next line to see the effect of leaving out 
        // the lock keyword:
        //下面的代码保证在当前线程修改balance的值完成之前 
        //不会有其他线程也执行这段代码来修改balance的值  
        //因此，balance的值是不可能小于0的  
        //如果没有lock关键字的保护，那么可能在执行完if的条件判断(成立)之后  
        //另外一个线程却执行了balance=balance-amount修改了balance的值 
        //而这个修改对这个线程是不可见的，所以可能导致这时if的条件已经不成立了 
        //但是，这个线程却继续执行 balance=balance-amount，所以导致balance可能小于0
        lock (thisLock)
        {
            if (balance >= amount)
            {
                Console.WriteLine("Balance before Withdrawal :  " + balance);
                Console.WriteLine("Amount to Withdraw        : -" + amount);
                balance = balance - amount;
                Console.WriteLine("Balance after Withdrawal  :  " + balance);
                return amount;
            }
            else
            {
                return 0; // transaction rejected
            }
        }
       
    }

    public void DoTransactions()
    {
        for (int i = 0; i < 100; i++)
        {
            Withdraw(r.Next(1, 100));
        }
    }
}

class Test
{
    static void Main()
    {
        Thread[] threads = new Thread[10];
        Account acc = new Account(1000);
        for (int i = 0; i < 10; i++)
        {
            Thread t = new Thread(new ThreadStart(acc.DoTransactions));
            threads[i] = t;
        }
        for (int i = 0; i < 10; i++)
        {
            threads[i].Start();
        }       
        Console.ReadKey();
    }
}