参考网址: https://blog.csdn.net/weixin_43989331/article/details/105356008

C#中的几种锁:用户模式锁、内核模式锁、动态计数、监视锁
介绍几种C#中的锁,最常用的是最后的监视锁,其他的也有必要了解一下原理及应用,特别像WaitOne、WaitHandle在我们项目中应用还是挺多的。

文章目录
C#中的几种锁:用户模式锁、内核模式锁、动态计数、监视锁
用户模式锁
内核模式锁
动态计数锁
监视锁

锁:解决多线程中的数据共享安全问题。
用户模式锁
volatile关键字:取消release对底层的优化,在读写的时候都从内存中读取

SpinLock 旋转锁:

SpinLock spinLock = new SpinLock();
bool lockTaken = false;
spinLock.Enter(ref lockTaken);
spinLock.Exit();

内核模式锁
分为:事件锁、信号量、互斥锁、读写锁。

建议:通常不建议随便使用内核模式锁,资源付出相对较大。我们可以使用混合锁代替,以及我们马上讲到的lock关键字。

事件锁(自动事件锁、手动事件锁):

自动事件锁:AutoResetEvent

AutoResetEvent myLock = new AutoResetEvent(true);//true:表示终止状态(初始状态),false表示非终止
myLock.WaitOne();
//...
myLock.Set();

手动事件锁:ManualResetEvent,和自动事件锁相比,差距在于可以对多个变量进行批量锁

ManualResetEvent myLock = new ManualResetEvent(false);//true:可以正常通过的。false:拦截状态,禁止通过。

myLock.WaitOne();//批量拦截
//...//由于是一批,这里是无序的
myLock.Set();

Semaphore 信号量

基本原理:是通过int数值来控制线程的个数

Semaphore myLock = new Semaphore(5, 10);//第一个参数表示同时可以允许的线程数,第二个是最大值

Semaphore myLock = new Semaphore(1, 10);//每次只能一个线程通过

Semaphore myLock = new Semaphore(1, 10);

myLock.WaitOne();
//...
myLock.Release();

  • Mutex互斥锁

    可用于非全局变量互斥的情况,如同一ID的用户只允许提交一次抽奖请求。

Mutex mutex = new Mutex();

mutex.WaitOne();
//...
mutex.ReleaseMutex();
 

以上三种锁都有WaitOne()方法,因为他们都继承自waitHandle。

读写锁ReaderWriterLock

注意:读写锁并不是从限定线程个数的角度出发。而是按照读写的功能划分。

读写锁的基本方案:多个线程可以一起读,只能让一个线程去写。

模拟场景:多个线程读取,一个线程写。请思考:写的线程是否能够正常阻止读的线程?如果能阻止,则达到目标。

static ReaderWriterLock readerWriterLock = new ReaderWriterLock();

/// <summary>
/// 读取数据的线程
/// </summary>
private static void ThreadRead()
{
while (true)
{
readerWriterLock.AcquireReaderLock(int.MaxValue);//参数:表示最大的超时时间

Thread.Sleep(100);
Console.WriteLine($"当前读取的tid={Thread.CurrentThread.ManagedThreadId} {DateTime.Now.ToLongTimeString()}");
readerWriterLock.ReleaseReaderLock();
}
}
/// <summary>
/// 写入数据的线程
/// </summary>
private static void ThreadWrite()
{
while (true)
{
readerWriterLock.AcquireWriterLock(int.MaxValue);//参数:表示最大的超时时间

Thread.Sleep(3000);
Console.WriteLine($"---------------------------------------------当前写入的tid={Thread.CurrentThread.ManagedThreadId} {DateTime.Now.ToLongTimeString()}");

readerWriterLock.ReleaseWriterLock();
}
}
//通过观察,我们发现写入的时候,能够正常的拦截读取的线程。
//PS:如果我们写入数据的任务耗时太长,比如十几秒或更长,此时读的线程会被卡死,从而超时。开发中要特别注意。

动态计数锁
CountdownEvent:限制线程数的一个机制,而且这个也是比较常用的(同属于信号量的一种).

使用场景:基于多个线程从某一个表中读取数据:比如我们现有A、B、C…每一张数据表我们都希望通过多个线程去读取。因为用一个线程的话,那么数据量大会出现卡死的情况。

举例:

A表:10w数据–》10个线程读取,1个线程1w条数据。
B表:5w数据 --》5个线程 1个线程1w
C表:1w数据 --》2个线程 1个线程5k

private static CountdownEvent countdownEvent = new CountdownEvent(10);
//默认10个threadcount初始值,一个线程用一个就减掉1,直到为0后,相当于结束
static void LoadData()
{
countdownEvent.Reset(10);//重置当前ThreadCount上限
for (int i = 0; i < 10; i++)
{
Task.Factory.StartNew(() =>
{
Thread.Sleep(500);
LoadTableA();
});
}

//阻止当前线程,直到设置了System.Threading.CountdonwEvent为止
countdownEvent.Wait();//相当于Task.WaitAll()

Console.WriteLine("TableA加载完毕..........\r\n");

//加载B表
countdownEvent.Reset(5);
for (int i = 0; i < 5; i++)
{
Task.Factory.StartNew(() =>
{
Thread.Sleep(500);
LoadTableB();
});
}
countdownEvent.Wait();
Console.WriteLine("TableB加载完毕..........\r\n");

//加载C表
myLock7.Reset(2);
for (int i = 0; i < 2; i++)
{
Task.Factory.StartNew(() =>
{
Thread.Sleep(500);
LoadTableC();
});
}
countdownEvent.Wait();
Console.WriteLine("TableC加载完毕..........\r\n");
}

/// <summary>
/// 加载A表
/// </summary>
private static void LoadTableA()
{
//在这里编写具体的业务逻辑...
Console.WriteLine($"当前TableA正在加载中...{Thread.CurrentThread.ManagedThreadId}");
countdownEvent.Signal();//将当前的ThreadCount-- 操作,就是减掉一个值
}

/// <summary>
/// 加载B表
/// </summary>
private static void LoadTableB()
{
//在这里编写具体的业务逻辑...
Console.WriteLine($"当前TableB正在加载中...{ Thread.CurrentThread.ManagedThreadId}");
countdownEvent.Signal();
}

/// <summary>
/// 加载C表
/// </summary>
private static void LoadTableC()
{
//在这里编写具体的业务逻辑...
Console.WriteLine($"当前TableC正在加载中...{Thread.CurrentThread.ManagedThreadId}");
countdownEvent.Signal();
}

动态计数锁
CountdownEvent:限制线程数的一个机制,而且这个也是比较常用的(同属于信号量的一种).

使用场景:基于多个线程从某一个表中读取数据:比如我们现有A、B、C…每一张数据表我们都希望通过多个线程去读取。因为用一个线程的话,那么数据量大会出现卡死的情况。

举例:

A表:10w数据–》10个线程读取,1个线程1w条数据。
B表:5w数据 --》5个线程 1个线程1w
C表:1w数据 --》2个线程 1个线程5k

private static CountdownEvent countdownEvent = new CountdownEvent(10);
//默认10个threadcount初始值,一个线程用一个就减掉1,直到为0后,相当于结束
static void LoadData()
{
countdownEvent.Reset(10);//重置当前ThreadCount上限
for (int i = 0; i < 10; i++)
{
Task.Factory.StartNew(() =>
{
Thread.Sleep(500);
LoadTableA();
});
}

//阻止当前线程,直到设置了System.Threading.CountdonwEvent为止
countdownEvent.Wait();//相当于Task.WaitAll()

Console.WriteLine("TableA加载完毕..........\r\n");

//加载B表
countdownEvent.Reset(5);
for (int i = 0; i < 5; i++)
{
Task.Factory.StartNew(() =>
{
Thread.Sleep(500);
LoadTableB();
});
}
countdownEvent.Wait();
Console.WriteLine("TableB加载完毕..........\r\n");

//加载C表
myLock7.Reset(2);
for (int i = 0; i < 2; i++)
{
Task.Factory.StartNew(() =>
{
Thread.Sleep(500);
LoadTableC();
});
}
countdownEvent.Wait();
Console.WriteLine("TableC加载完毕..........\r\n");
}

/// <summary>
/// 加载A表
/// </summary>
private static void LoadTableA()
{
//在这里编写具体的业务逻辑...
Console.WriteLine($"当前TableA正在加载中...{Thread.CurrentThread.ManagedThreadId}");
countdownEvent.Signal();//将当前的ThreadCount-- 操作,就是减掉一个值
}

/// <summary>
/// 加载B表
/// </summary>
private static void LoadTableB()
{
//在这里编写具体的业务逻辑...
Console.WriteLine($"当前TableB正在加载中...{ Thread.CurrentThread.ManagedThreadId}");
countdownEvent.Signal();
}

/// <summary>
/// 加载C表
/// </summary>
private static void LoadTableC()
{
//在这里编写具体的业务逻辑...
Console.WriteLine($"当前TableC正在加载中...{Thread.CurrentThread.ManagedThreadId}");
countdownEvent.Signal();
}

动态计数锁
CountdownEvent:限制线程数的一个机制,而且这个也是比较常用的(同属于信号量的一种).

使用场景:基于多个线程从某一个表中读取数据:比如我们现有A、B、C…每一张数据表我们都希望通过多个线程去读取。因为用一个线程的话,那么数据量大会出现卡死的情况。

举例:

A表:10w数据–》10个线程读取,1个线程1w条数据。
B表:5w数据 --》5个线程 1个线程1w
C表:1w数据 --》2个线程 1个线程5k

private static CountdownEvent countdownEvent = new CountdownEvent(10);
//默认10个threadcount初始值,一个线程用一个就减掉1,直到为0后,相当于结束
static void LoadData()
{
countdownEvent.Reset(10);//重置当前ThreadCount上限
for (int i = 0; i < 10; i++)
{
Task.Factory.StartNew(() =>
{
Thread.Sleep(500);
LoadTableA();
});
}

//阻止当前线程,直到设置了System.Threading.CountdonwEvent为止
countdownEvent.Wait();//相当于Task.WaitAll()

Console.WriteLine("TableA加载完毕..........\r\n");

//加载B表
countdownEvent.Reset(5);
for (int i = 0; i < 5; i++)
{
Task.Factory.StartNew(() =>
{
Thread.Sleep(500);
LoadTableB();
});
}
countdownEvent.Wait();
Console.WriteLine("TableB加载完毕..........\r\n");

//加载C表
myLock7.Reset(2);
for (int i = 0; i < 2; i++)
{
Task.Factory.StartNew(() =>
{
Thread.Sleep(500);
LoadTableC();
});
}
countdownEvent.Wait();
Console.WriteLine("TableC加载完毕..........\r\n");
}

/// <summary>
/// 加载A表
/// </summary>
private static void LoadTableA()
{
//在这里编写具体的业务逻辑...
Console.WriteLine($"当前TableA正在加载中...{Thread.CurrentThread.ManagedThreadId}");
countdownEvent.Signal();//将当前的ThreadCount-- 操作,就是减掉一个值
}

/// <summary>
/// 加载B表
/// </summary>
private static void LoadTableB()
{
//在这里编写具体的业务逻辑...
Console.WriteLine($"当前TableB正在加载中...{ Thread.CurrentThread.ManagedThreadId}");
countdownEvent.Signal();
}

/// <summary>
/// 加载C表
/// </summary>
private static void LoadTableC()
{
//在这里编写具体的业务逻辑...
Console.WriteLine($"当前TableC正在加载中...{Thread.CurrentThread.ManagedThreadId}");
countdownEvent.Signal();
}

C#中的几种锁:用户模式锁、内核模式锁、动态计数、监视锁的更多相关文章

  1. 【windows 操作系统】【CPU】用户模式和内核模式(用户层和内核层)

    所有的现代操作系统中,CPU是在两种不同的模式下运行的: 注意以下内容来自微软: windows用户模式和内核模式 运行 Windows 的计算机中的处理器有两个不同模式:用户模式 和内核模式 . 用 ...

  2. 理解Windows内核模式与用户模式

     1.基础 执行 Windows 的计算机中的处理器有两个不同模式:"用户模式"和"内核模式". 依据处理器上执行的代码的类型,处理器在两个模式之间切换.应 ...

  3. Windows系统的四个重要概念——进程、线程、虚拟内存、内核模式和用户模式

    引言 本来在写一篇Windows内存管理的文章,写着写着就发现好多基础的概念都要先讲.更可怕的是,这些基础的概念我却不能完全讲清楚.只好再把这本<深入解析Windows操作系统>翻到第一章 ...

  4. 如何看待Linux操作系统的用户空间和内核空间

    作为中央核心处理单元的CPU,除了生产工艺的不断革新进步外,在处理数据和响应速度方面也需要有权衡.稍有微机原理基础的人都知道Intel X86体系的CPU提供了四种特权模式ring0~ring3,其中 ...

  5. Linux 用户态和内核态

    1.特权级特权级用来管理和控制程序执行.如Intel x86架构的CPU,有0~3四个特权级,0级最高,3级最低.硬件在执行每条指令时都会检查指令具有的特权级.硬件提供了特权级使用机制,对操作系统来说 ...

  6. 监视锁——Java同步的基本思想

    翻译人员: 铁锚翻译时间: 2013年11月13日原文链接: Monitors – The Basic Idea of Java synchronization如果你上过操作系统课程,你就知道监视锁( ...

  7. 使用WinDbg调试入门(内核模式)

    windbg是一个内核模式和用户模式调试器,包含在Windows调试工具中.这里我们提供了一些实践练习,可以帮助您开始使用windbg作为内核模式调试器. 设置内核模式调试 内核模式调试环境通常有两台 ...

  8. 内核模式构造-Event构造(WaitLock)

    internal sealed class SimpleWaitLock:IDisposable { //Enter()和Leave()中使用m_AutoResetEvent都将迫使调用线程做用户模式 ...

  9. 全面了解Java中的15种锁概念及机制!

    在读很多并发文章中,会提及各种各样锁如公平锁,乐观锁等等,这篇文章介绍各种锁的分类.介绍的内容如下: 1.公平锁 / 非公平锁 2.可重入锁 / 不可重入锁 3.独享锁 / 共享锁 4.互斥锁 / 读 ...

随机推荐

  1. 一次性讲清楚spring中bean的生命周期之三:bean是如何实例化的

    在前面的两篇博文<一次性讲清楚spring中bean的生命周期之一:getSingleton方法>和<一次性讲清楚spring中bean的生命周期之二:FactoryBean的前世今 ...

  2. 如何修改Windows 11 任务栏大小

    1.首先Win+R输入regedit打开注册表编辑器         2.进入注册表编辑器后,在地址栏中输入: HKEY_CURRENT_USER\Software\Microsoft\ Window ...

  3. nodejs安装+vue安装

    一.nodejs安装 电脑win7的,nodejs V12.16.2以前的版本支持win7 nodejs下载地址: http://mirrors.nju.edu.cn/nodejs/v12.15.0/ ...

  4. DEV -C++源码中的中文复制粘贴乱码解决方案

    右击源代码用记事本打开,再复制,再粘贴,就没有乱码了

  5. python 异常获取方法

    import sys #第1:print(6/0) #直接运行该命令,出现异常,程序终止 #异常提示: '''Traceback (most recent call last): File " ...

  6. python twain模块

    >>> help(twain) Help on module twain: NAME twain - Created on Sep 4, 2011 DESCRIPTION @auth ...

  7. JAVA中自增自减运算符(i++与++i的区别)

    注意: 自增运算符和自减运算符只能用于变量,而不能用于常亮或表达式 运算符 运算 范例 结果 ++ 自增(前):先运算后取值 a=2;b=++a; a=3;b=3; ++ 自增(后):先取值后运算 a ...

  8. 第 1 题:HTML 和 HTML5 有什么区别?

    概念 HTML5 将成为 HTML.XHTML 以及 HTML DOM 的新标准 文档类型声明 HTML <!DOCTYPE html PUBLIC "-//W3C//DTD HTML ...

  9. 牛客OI测试赛1

    题目链接: https://www.nowcoder.com/acm/contest/181#question A.斐波拉契 求$f[n-1]*f[n+1]-f[n]^2$,$f[n]$为斐波拉契数列 ...

  10. P7362 [eJOI 2020 Day2] XOR Sort

    P7362 [eJOI 2020 Day2] XOR Sort 题意 给你一个长度为 \(n\) 的序列,每次操作可以将一个数异或上相邻的一个数,求将序列改为严格单调递增序列或严格单调不降序列的操作次 ...