C#怎么使用LOCK实现线程同步

本篇内容介绍了“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就失去了作用。所以一般情况下，使用私有的、静态的并且是只读的对象

“C#怎么使用LOCK实现线程同步”的内容就介绍到这里了，感谢大家的阅读。如果想了解更多行业相关的知识可以关注编程网网站，小编将为大家输出更多高质量的实用文章！