开发者社区 开发与运维 文章 正文

C#多线程系列(2):多 线程锁lock和Monitor

2022-05-03 434
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： C#多线程系列(2):多 线程锁lock和Monitor

C# 中，可以使用 lock 关键字和 Monitor 类来解决多线程锁定资源和死锁的问题。

官方解释：lock 语句获取给定对象的互斥 lock，执行语句块，然后释放 lock。

下面我们将来探究 lock 关键字和 Monitor 类的使用。


1，Lock

lock 用于读一个引用类型进行加锁，同一时刻内只有一个线程能够访问此对象。lock 是语法糖，是通过 Monitor 来实现的。


Lock 锁定的对象，应该是静态的引用类型（字符串除外）。


实际上字符串也可以作为锁的对象使用，只是由于字符串对象的特殊性，可能会造成不同位置的不同线程冲突。

如果你能保证字符串的唯一性，例如 Guid 生成的字符串，也是可以作为锁的对象使用的(但不建议)。

锁的对象也不一定要静态才行，也可以通过类实例的成员变量，作为锁对象。


lock 原型

lock 是 Monitor 的语法糖，生成的代码对比：

lock (x)
{
    // Your code...
}


object __lockObj = x;
bool __lockWasTaken = false;
try
{
    System.Threading.Monitor.Enter(__lockObj, ref __lockWasTaken);
    // Your code...
}
finally
{
    if (__lockWasTaken) System.Threading.Monitor.Exit(__lockObj);
}

这里先不理会 Monitor，后面再说。


lock 编写实例


首先，如果像下面这样写的话，拉出去打 si 吧。

public void MyLock()
        {
            object o = new object();
            lock (o)
            {
            // 
            }
        }


下面编写一个简单的锁，示例如下：

class Program
    {
        private static object obj = new object();
        private static int sum = 0;
        static void Main(string[] args)
        {
            Thread thread1 = new Thread(Sum1);
            thread1.Start();
            Thread thread2 = new Thread(Sum2);
            thread2.Start();
            while (true)
            {
                Console.WriteLine($"{DateTime.Now.ToString()}:" + sum);
                Thread.Sleep(TimeSpan.FromSeconds(1));
            }
        }
        public static void Sum1()
        {
            sum = 0;
            lock (obj)
            {
                for (int i = 0; i < 10; i++)
                {
                    sum += i;
                    Console.WriteLine("Sum1");
                    Thread.Sleep(TimeSpan.FromSeconds(2));
                }
            }
        }
        public static void Sum2()
        {
            sum = 0;
            lock (obj)
            {
                for (int i = 0; i < 10; i++)
                {
                    sum += 1;
                    Console.WriteLine("Sum2");
                    Thread.Sleep(TimeSpan.FromSeconds(2));
                }
            }
        }
    }


类将自己设置为锁， 这可以防止恶意代码对公共对象采用做锁。

例如：

public void Access()
    {
        lock(this) {}
     }


锁可以阻止其它线程执行锁块(lock(o){})中的代码，当锁定时，其它线程必须等待锁中的线程执行完成并释放锁。但是这可能会给程序带来性能影响。

锁不太适合I/O场景，例如文件I/O，繁杂的计算或者操作比较持久的过程，会给程序带来很大的性能损失。

10 种优化锁的性能方法： http://www.thinkingparallel.com/2007/07/31/10-ways-to-reduce-lock-contention-in-threaded-programs/


2，Monitor

此对象提供同步访问对象的机制；Monotor 是一个静态类型，其方法比较少，常用方法如下：


操作 说明
Enter， TryEnter 获取对象的锁。 此操作还标记关键节的开头。 其他任何线程都不能输入临界区，除非它使用不同的锁定对象执行临界区中的说明。
Wait 释放对象的锁，以允许其他线程锁定并访问对象。 调用线程会等待另一个线程访问对象。 使用脉冲信号通知等待线程关于对象状态的更改。
Pulse 、PulseAll 将信号发送到一个或多个等待线程。 信号通知等待线程：锁定对象的状态已更改，锁的所有者已准备好释放该锁。 正在等待的线程置于对象的就绪队列中，因此它可能最终接收对象的锁。 线程锁定后，它可以检查对象的新状态，以查看是否已达到所需的状态。
Exit 释放对象的锁。 此操作还标记受锁定对象保护的临界区的结尾。


怎么用呢

下面是一个很简单的示例：


private static object obj = new object();
        private static bool acquiredLock = false;
    public static void Test()
        {
            try
            {
                Monitor.Enter(obj, ref acquiredLock);
            }
            catch { }
            finally
            {
                if (acquiredLock)
                    Monitor.Exit(obj);
            }
        }


Monitor.Enter 锁定 obj 这个对象，并且设置 acquiredLock 为 true，告诉别人 obj 已经被锁定。

最后结束时，判断 acquiredLock ，释放锁，并设置 acquiredLock 为 false。


解释一下

临界区：指被某些符号包围的范围。例如 {} 内。

Monitor 对象的 Enter 和 Exit 方法来标记临界区的开头和结尾。

Enter() 方法获取锁后，能够保证只有单个线程能够使用临界区中的代码。使用 Monitor 类，最好搭配 try{...}catch{...}finally{...} 来使用，因为如果获取到锁但是没有释放锁的话，会导致其它线程无限阻塞，即发生死锁。

一般来说，lock 关键字够用了。


示例

下面示范了多个线程如何使用 Monitor 来实现锁：


private static object obj = new object();
        private static bool acquiredLock = false;
        static void Main(string[] args)
        {
            new Thread(Test1).Start();
            Thread.Sleep(1000);
            new Thread(Test2).Start();
        }
        public static void Test1()
        {
            try
            {
                Monitor.Enter(obj, ref acquiredLock);
                for (int i = 0; i < 10; i++)
                {
                    Console.WriteLine("Test1正在锁定资源");
                    Thread.Sleep(1000);
                }
            }
            catch { }
            finally
            {
                if (acquiredLock)
                    Monitor.Exit(obj);
                Console.WriteLine("Test1已经释放资源");
            }
        }
        public static void Test2()
        {
            bool isGetLock = false;
            Monitor.Enter(obj);
            try
            {
                Monitor.Enter(obj, ref acquiredLock);
                for (int i = 0; i < 10; i++)
                {
                    Console.WriteLine("Test2正在锁定资源");
                    Thread.Sleep(1000);
                }
            }
            catch { }
            finally
            {
                if (acquiredLock)
                    Monitor.Exit(obj);
                Console.WriteLine("Test2已经释放资源");
            }
        }


设置获取锁的时效

如果对象已经被锁定，另一个线程使用 Monitor.Enter 对象，就会一直等待另一个线程解除锁定。


但是，如果一个线程发生问题或者出现死锁的情况，锁一直被锁定呢？或者线程具有时效性，超过一段时间不执行，已经没有了意义呢？

我们可以通过 Monitor.TryEnter() 来设置等待时间，超过一段时间后，如果锁还没有释放，就会返回 false。


改造上面的示例如下：

private static object obj = new object();
        private static bool acquiredLock = false;
        static void Main(string[] args)
        {
            new Thread(Test1).Start();
            Thread.Sleep(1000);
            new Thread(Test2).Start();
        }
        public static void Test1()
        {
            try
            {
                Monitor.Enter(obj, ref acquiredLock);
                for (int i = 0; i < 10; i++)
                {
                    Console.WriteLine("Test1正在锁定资源");
                    Thread.Sleep(1000);
                }
            }
            catch { }
            finally
            {
                if (acquiredLock)
                    Monitor.Exit(obj);
                Console.WriteLine("Test1已经释放资源");
            }
        }
        public static void Test2()
        {
            bool isGetLock = false;
            isGetLock = Monitor.TryEnter(obj, 500);
            if (isGetLock == false)
            {
                Console.WriteLine("锁还没有释放，我不干活了");
                return;
            }
            try
            {
                Monitor.Enter(obj, ref acquiredLock);
                for (int i = 0; i < 10; i++)
                {
                    Console.WriteLine("Test2正在锁定资源");
                    Thread.Sleep(1000);
                }
            }
            catch { }
            finally
            {
                if (acquiredLock)
                    Monitor.Exit(obj);
                Console.WriteLine("Test2已经释放资源");
            }
        }


对于锁的使用，还有很多高级复杂的技术，本文简单地介绍了 Lock 和 Monitor 的使用。

随着教程的深入，会继续学习很多高级的使用方法。

文章标签：
C#
关键词：
线程锁
线程多线程
线程lock
多线程线程
C#锁
痴者工良
目录
相关文章
栈江湖
|
3天前
|
NoSQL Redis
单线程传奇Redis，为何引入多线程？
Redis 4.0 引入多线程支持，主要用于后台对象删除、处理阻塞命令和网络 I/O 等操作，以提高并发性和性能。尽管如此，Redis 仍保留单线程执行模型处理客户端请求，确保高效性和简单性。多线程仅用于优化后台任务，如异步删除过期对象和分担读写操作，从而提升整体性能。
栈江湖
12 1
东方睿赢
|
1月前
|
Java 开发者
在Java多线程编程的世界里，Lock接口正逐渐成为高手们的首选，取代了传统的synchronized关键字
在Java多线程编程的世界里，Lock接口正逐渐成为高手们的首选，取代了传统的synchronized关键字
东方睿赢
47 4
石小浪♪
|
2月前
|
存储 消息中间件 资源调度
C++ 多线程之初识多线程
这篇文章介绍了C++多线程的基本概念，包括进程和线程的定义、并发的实现方式，以及如何在C++中创建和管理线程，包括使用`std::thread`库、线程的join和detach方法，并通过示例代码展示了如何创建和使用多线程。
石小浪♪
60 1
龙大吉
|
2月前
|
Java 开发者
在Java多线程编程中，创建线程的方法有两种：继承Thread类和实现Runnable接口
【10月更文挑战第20天】在Java多线程编程中，创建线程的方法有两种：继承Thread类和实现Runnable接口。本文揭示了这两种方式的微妙差异和潜在陷阱，帮助你更好地理解和选择适合项目需求的线程创建方式。
龙大吉
32 3
东方睿赢
|
2月前
|
Java 开发者
在Java多线程编程中，选择合适的线程创建方法至关重要
【10月更文挑战第20天】在Java多线程编程中，选择合适的线程创建方法至关重要。本文通过案例分析，探讨了继承Thread类和实现Runnable接口两种方法的优缺点及适用场景，帮助开发者做出明智的选择。
东方睿赢
25 2
东方睿赢
|
2月前
|
Java
Java中多线程编程的基本概念和创建线程的两种主要方式：继承Thread类和实现Runnable接口
【10月更文挑战第20天】《JAVA多线程深度解析：线程的创建之路》介绍了Java中多线程编程的基本概念和创建线程的两种主要方式：继承Thread类和实现Runnable接口。文章详细讲解了每种方式的实现方法、优缺点及适用场景，帮助读者更好地理解和掌握多线程编程技术，为复杂任务的高效处理奠定基础。
东方睿赢
41 2
龙大吉
|
2月前
|
Java 开发者
Java多线程初学者指南：介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点
【10月更文挑战第20天】Java多线程初学者指南：介绍通过继承Thread类与实现Runnable接口两种方式创建线程的方法及其优缺点，重点解析为何实现Runnable接口更具灵活性、资源共享及易于管理的优势。
龙大吉
47 1
众所周知
|
2月前
|
安全 Java 开发者
Java多线程中的`wait()`、`notify()`和`notifyAll()`方法，探讨了它们在实现线程间通信和同步中的关键作用
本文深入解析了Java多线程中的`wait()`、`notify()`和`notifyAll()`方法，探讨了它们在实现线程间通信和同步中的关键作用。通过示例代码展示了如何正确使用这些方法，并分享了最佳实践，帮助开发者避免常见陷阱，提高多线程程序的稳定性和效率。
众所周知
53 1
众所周知
|
2月前
|
Java
在Java多线程编程中，`wait()` 和 `notify()/notifyAll()` 方法是线程间通信的核心机制。
在Java多线程编程中，`wait()` 和 `notify()/notifyAll()` 方法是线程间通信的核心机制。它们通过基于锁的方式，使线程在条件不满足时进入休眠状态，并在条件成立时被唤醒，从而有效解决数据一致性和同步问题。本文通过对比其他通信机制，展示了 `wait()` 和 `notify()` 的优势，并通过生产者-消费者模型的示例代码，详细说明了其使用方法和重要性。
众所周知
41 1
XIAZHI
|
1月前
|
数据采集 Java Python
爬取小说资源的Python实践：从单线程到多线程的效率飞跃
本文介绍了一种使用Python从笔趣阁网站爬取小说内容的方法，并通过引入多线程技术大幅提高了下载效率。文章首先概述了环境准备，包括所需安装的库，然后详细描述了爬虫程序的设计与实现过程，包括发送HTTP请求、解析HTML文档、提取章节链接及多线程下载等步骤。最后，强调了性能优化的重要性，并提醒读者遵守相关法律法规。
XIAZHI
66 0