多线程的锁具体怎样应用?实际开发的应用等等,望高手指导

Question

不知道锁定一个object有什么用,什么情况下要这样,概念我看了很多,还是没弄明白,小白一个,希望大家指导指导比如Lock(obj)
{
**
}有什么用

Answer 1

假设 下载你又两个线程 Thread1 和 Thread2
这两个线程调用的都是同一个方法Method（）现在 这两个线程 都启动 
Thread1.Start（）；
Thread2.Start（）；现在Thread1进入了那个Method方法 紧接着 Thread2进入Method方法
加入Method里面是这样的
Method（）{
int temp = 0；
/...代码段1 
temp = XX //重新赋值
/...代码段2
}加入这个时候 Thread1执行到temp = XX 那一句了 那个 Thread2 执行到int temp = 0；
那么 Thread1 在代码段2中temp的值又变成了 0；被Thread2那个线程修改了lock（object）{
这里面的代码锁住（这个里面不一定要操作object 反正我是声明一个object出来作为锁代码用的）
}//离开这个括号才解锁object 其他的代码才能对这个object操作如果哪里 你把那个Method方法锁住的话 那个Thread1进入里面后 Thread2就无法进入  等到Thread1执行完了Thread2才能进去反正 我就是这样理解的 不可全信、、、

Answer 2

进入这段代码必须先取得obj，而obj被锁了不可同时访问，得排队
而如果锁一个现成的对象，这个对象可能在别处也会被访问，导致排队反正 我就是这样理解的 不可全信、、、

Answer 3

lock(obj)就相当于告诉程序中的线程，我独占了obj这个对象资源，其他资源先等待等我运行完就释放你们就可以进入了
lock本质上是Monitor.Enter、Monitor.Leave，相当于圈定一个保护区域，在这个保护区域的代码只能由一个线程独占，排他性。

Answer 4

哦,明白了,那计算器有什么用呢,和lock有什么区别

Answer 5

不是计算器,监视器Monitor

Answer 6

class LockTest
    {
        private int _MaxIndex;
        public int MaxIndex
        {
            get { return _MaxIndex; }
        }
        public LockTest()
        {
            this._MaxIndex = 0;
        }
        //无锁
        public void Add()
        {
            this._MaxIndex++;
        }        //有锁
        public void Add_LockTest()
        {
            lock (this)
            {
                this._MaxIndex++;
            }
        }
    }
    class Program
    {
        static void Main(string[] args)
        {
            LockTest abc = new LockTest();            for (int i = 1; i <= 1000; i++)
            {
                abc.Add();
            }
            Console.WriteLine(abc.MaxIndex); //1000这是肯定的            //以下仅是演示,在实际切莫这样做            abc = new LockTest();   //重新实例        
            List<System.Threading.Thread> MyThreads = new List<System.Threading.Thread>();
            //装入线程
            for (int i = 1; i <= 1000; i++)
            {
                System.Threading.Thread mythread = new System.Threading.Thread((obj) =>
                {
                    abc.Add(); //无锁
                });
                MyThreads.Add(mythread);
            }
            foreach (var thread in MyThreads)
            {
                thread.Start(); //启动线程
            }
            foreach (var thread in MyThreads)
            {
                thread.Join();
            }
            Console.WriteLine(abc.MaxIndex); //这里不一定是1000了,即便是也是偶然,因为多个线程同时改ABC类的_MaxIndex这个变量
            abc = new LockTest();   //重新实例      
            MyThreads = new List<System.Threading.Thread>();
            //装入线程
            for (int i = 1; i <= 1000; i++)
            {
                System.Threading.Thread mythread = new System.Threading.Thread((obj) =>
                {
                    abc.Add_LockTest(); //有锁
                });
                MyThreads.Add(mythread);
            }
            foreach (var thread in MyThreads)
            {
                thread.Start(); //启动线程
            }
            foreach (var thread in MyThreads)
            {
                thread.Join();
            }
            Console.WriteLine(abc.MaxIndex);  //1000这是肯定的,这是因为更改ABC类的_MaxIndex变量时,不允许多个线程同时操作(使用了 Lock锁)
            Console.Read();
        }
    }