参考网址: 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();
}