C#使用LOCK实现线程同步

一、简介

线程安全概念：线程安全是指在当一个线程访问该类的某个数据时，进行保护，其他线程不能进行访问直到该线程读取完，其他线程才可使用。不会出现数据不一致或者数据污染。

线程有可能和其他线程共享一些资源，比如，内存，文件，数据库等。当多个线程同时读写同一份共享资源的时候，可能会引起冲突。这时候，我们需要引入线程“同步”机制，即各位线程之间要有个先来后到，不能一窝蜂挤上去抢作一团。线程同步的真实意思和字面意思恰好相反。线程同步的真实意思，其实是“排队”：几个线程之间要排队，一个一个对共享资源进行操作，而不是同时进行操作。

二、代码

下面将通过简单的四个案例进行对比，来讲解LOCK的实现线程同步使用。

案例一：

首先创建两个线程，两个线程执行同一个方法，代码如下：

class Program
    {
        static void Main(string[] args)
        {
            Thread threadA = new Thread(ThreadMethod); //执行的必须是无返回值的方法 
            threadA.Name = "threadA";
            Thread threadB = new Thread(ThreadMethod); //执行的必须是无返回值的方法 
            threadB.Name = "threadB";
            threadA.Start();
            threadB.Start();
            Console.ReadKey();
        }
        public static void ThreadMethod(object parameter)
        {
            for (int i = 1; i <= 10; i++)
            {
                Console.WriteLine("我是:{0},我循環{1}次", Thread.CurrentThread.Name, i);
                Thread.Sleep(1000);//休眠一秒
            }
        }
    }

通过下面的执行结果，可以很清楚的看到，两个线程是在同时执行ThreadMethod这个方法，这显然不符合我们线程同步的要求。

执行结果：

案例二：

通过对上面代码的修改如下：

class Program
    {
        static void Main(string[] args)
        {
            Program pro = new Program();
            Thread threadA = new Thread(pro.ThreadMethod); 
            threadA.Name = "threadA";
            Thread threadB = new Thread(pro.ThreadMethod); 
            threadB.Name = "threadB";
            threadA.Start();
            threadB.Start();
            Console.ReadKey();
        }
        public void ThreadMethod(object parameter)
        {
            lock (this) //添加lock关键字
            {
                for (int i = 1; i <= 10; i++)
                {
                    Console.WriteLine("我是:{0},我循環{1}次", Thread.CurrentThread.Name, i);
                    Thread.Sleep(1000);//休眠一秒
                }
            }
        }
    }

执行结果：

我们通过添加了 lock(this) {...}代码，查看执行结果实现了我们想要的线程同步需求。

案例三：

但是我们知道this表示当前类实例的本身，那么有这么一种情况，我们把需要访问的方法所在的类型进行两个实例A和B，线程A访问实例A的方法ThreadMethod，线程B访问实例B的方法ThreadMethod，这样的话还能够达到线程同步的需求吗？

修改后的代码如下：

class Program
    {
        static void Main(string[] args)
        {
            Program pro1 = new Program();
            Program pro2 = new Program();
            Thread threadA = new Thread(pro1.ThreadMethod); 
            threadA.Name = "threadA";
            Thread threadB = new Thread(pro2.ThreadMethod); 
            threadB.Name = "threadB";
            threadA.Start();
            threadB.Start();
            Console.ReadKey();
        }
        public void ThreadMethod(object parameter)
        {
            lock (this) //添加lock关键字
            {
                for (int i = 1; i <= 10; i++)
                {
                    Console.WriteLine("我是:{0},我循環{1}次", Thread.CurrentThread.Name, i);
                    Thread.Sleep(1000);//休眠一秒
                }
            }
        }
    }

执行结果：

我们会发现，线程又没有实现同步了！lock(this)对于这种情况是不行的！

案例四：

通过对上面代码再次进行如下修改：

class Program
    {
        private static object obj = new object();
        static void Main(string[] args)
        {
            Program pro1 = new Program();
            Program pro2 = new Program();
            Thread threadA = new Thread(pro1.ThreadMethod); 
            threadA.Name = "threadA";
            Thread threadB = new Thread(pro2.ThreadMethod); 
            threadB.Name = "threadB";
            threadA.Start();
            threadB.Start();
            Console.ReadKey();
        }
        public void ThreadMethod(object parameter)
        {
            lock (obj) //添加lock关键字
            {
                for (int i = 1; i <= 10; i++)
                {
                    Console.WriteLine("我是:{0},我循環{1}次", Thread.CurrentThread.Name, i);
                    Thread.Sleep(1000);//休眠一秒
                }
            }
        }
    }

执行结果：

通过查看执行结果。会发现代码实现了我们的需求。

那么 lock(this) 和lock(Obj)有什么区别呢？

lock(this) 锁定 当前实例对象，如果有多个类实例的话，lock锁定的只是当前类实例，对其它类实例无影响。所有不推荐使用。
lock(typeof(Model))锁定的是model类的所有实例。
lock(obj)锁定的对象是全局的私有化静态变量。外部无法对该变量进行访问。
lock 确保当一个线程位于代码的临界区时，另一个线程不进入临界区。如果其他线程试图进入锁定的代码，则它将一直等待（即被阻止），直到该对象被释放。
所以，lock的结果好不好，还是关键看锁的谁，如果外边能对这个谁进行修改，lock就失去了作用。所以一般情况下，使用私有的、静态的并且是只读的对象

三、总结

• 1.lock的是必须是引用类型的对象，string类型除外。
• 2.lock推荐的做法是使用静态的、只读的、私有的对象。
• 3.保证lock的对象在外部无法修改才有意义，如果lock的对象在外部改变了，对其他线程就会畅通无阻，失去了lock的意义。

不能锁定字符串，锁定字符串尤其危险，因为字符串被公共语言运行库 (CLR)“暂留”。 这意味着整个程序中任何给定字符串都只有一个实例，就是这同一个对象表示了所有运行的应用程序域的所有线程中的该文本。因此，只要在应用程序进程中的任何位置处具有相同内容的字符串上放置了锁，就将锁定应用程序中该字符串的所有实例。通常，最好避免锁定 public 类型或锁定不受应用程序控制的对象实例。例如，如果该实例可以被公开访问，则 lock(this) 可能会有问题，因为不受控制的代码也可能会锁定该对象。这可能导致死锁，即两个或更多个线程等待释放同一对象。出于同样的原因，锁定公共数据类型（相比于对象）也可能导致问题。而且lock(this)只对当前对象有效，如果多个对象之间就达不到同步的效果。lock(typeof(Class))与锁定字符串一样，范围太广了。

到此这篇关于C#使用LOCK实现线程同步的文章就介绍到这了。希望对大家的学习有所帮助，也希望大家多多支持猪先飞。