This article mainly introduces the ReaderWriterLockSlim class to implement read-write separation in a multithreaded environment.
ReaderWriterLockSlim
ReaderWriterLock class: Defines a lock that supports a single writing thread and multiple reading threads.
ReaderWriterLockSlim class: Represents a lock that manages the state of resource access, allowing multithreaded reading or exclusive writing access.
Both classes allow multiple threads to read simultaneously, but only one thread can write at a time.
ReaderWriterLockSlim
As usual, let's first get an overview of the commonly used methods in ReaderWriterLockSlim.
Common Methods
| Method | Description |
|------------------------------------|---------------------------------------------------------|
| EnterReadLock() | Attempts to enter the read lock mode. |
| EnterUpgradeableReadLock() | Attempts to enter the upgradeable read lock mode. |
| EnterWriteLock() | Attempts to enter the write lock mode. |
| ExitReadLock() | Decreases the recursion count for the read mode and exits if the count is zero. |
| ExitUpgradeableReadLock() | Decreases the recursion count for the upgradeable mode and exits if the count is zero. |
| ExitWriteLock() | Decreases the recursion count for the write mode and exits if the count is zero. |
| TryEnterReadLock(Int32) | Attempts to enter the read lock mode with an optional integer timeout. |
| TryEnterReadLock(TimeSpan) | Attempts to enter the read lock mode with an optional timeout. |
| TryEnterUpgradeableReadLock(Int32) | Attempts to enter the upgradeable read lock mode with an optional timeout. |
| TryEnterUpgradeableReadLock(TimeSpan) | Attempts to enter the upgradeable read lock mode with an optional timeout. |
| TryEnterWriteLock(Int32) | Attempts to enter the write lock mode with an optional timeout. |
| TryEnterWriteLock(TimeSpan) | Attempts to enter the write lock mode with an optional timeout. |
The template for locking read and write operations using ReaderWriterLockSlim is as follows:
private static ReaderWriterLockSlim toolLock = new ReaderWriterLockSlim();
// Read
private T Read()
{
try
{
toolLock.EnterReadLock(); // Acquire read lock
return obj;
}
catch { }
finally
{
toolLock.ExitReadLock(); // Release read lock
}
return default;
}
// Write
public void Write(int key, int value)
{
try
{
toolLock.EnterUpgradeableReadLock();
try
{
toolLock.EnterWriteLock();
/*
*
*/
}
catch
{
}
finally
{
toolLock.ExitWriteLock();
}
}
catch { }
finally
{
toolLock.ExitUpgradeableReadLock();
}
}
Order System Example
Let's simulate a simple order system.
Before coding, let's understand the specific usage of some methods.
EnterReadLock() / TryEnterReadLock and ExitReadLock() appear in pairs.
EnterWriteLock() / TryEnterWriteLock() and ExitWriteLock() appear in pairs.
EnterUpgradeableReadLock() enters the upgradeable read lock state.
Using EnterReadLock() in conjunction with EnterUpgradeableReadLock() allows a smooth transition to write mode at the appropriate time via EnterWriteLock() (the reverse can also apply).
Define three variables:
ReaderWriterLockSlimfor multithreaded read-write locks;MaxIdfor the maximum value of the current order Id;ordersfor the order table;
private static ReaderWriterLockSlim tool = new ReaderWriterLockSlim(); // Read-write lock
private static int MaxId = 1;
public static List<DoWorkModel> orders = new List<DoWorkModel>(); // Order table
// Order model
public class DoWorkModel
{
public int Id { get; set; } // Order number
public string UserName { get; set; } // Customer name
public DateTime DateTime { get; set; } // Creation time
}
Next, implement two methods for querying and creating orders.
Pagination Query for Orders:
Use EnterReadLock() to acquire the lock before reading; after reading, release the lock with ExitReadLock().
This ensures that every read operation in a multithreaded environment reflects the latest values.
// Paginate query for orders
private static DoWorkModel[] DoSelect(int pageNo, int pageSize)
{
try
{
DoWorkModel[] doWorks;
tool.EnterReadLock(); // Acquire read lock
doWorks = orders.Skip((pageNo - 1) * pageSize).Take(pageSize).ToArray();
return doWorks;
}
catch { }
finally
{
tool.ExitReadLock(); // Release read lock
}
return default;
}
Creating an Order:
Creating an order is straightforward; you only need the username and creation time.
It is essential that each Id is unique in the order system (in practice, it should be a Guid). For demonstration purposes of the read-write lock, we use numbers.
In a multithreaded environment, we do not use Interlocked.Increment() but rather += 1, as we have the read-write lock safeguarding the operation.
// Create order
private static DoWorkModel DoCreate(string userName, DateTime time)
{
try
{
tool.EnterUpgradeableReadLock(); // Upgrade
try
{
tool.EnterWriteLock(); // Acquire write lock
// Write order
MaxId += 1; // Interlocked.Increment(ref MaxId);
DoWorkModel model = new DoWorkModel
{
Id = MaxId,
UserName = userName,
DateTime = time
};
orders.Add(model);
return model;
}
catch { }
finally
{
tool.ExitWriteLock(); // Release write lock
}
}
catch { }
finally
{
tool.ExitUpgradeableReadLock(); // Downgrade
}
return default;
}
In the Main method:
Five threads are started to continuously read, and two threads are started to continuously create orders. Since Thread.Sleep() is not set during order creation, the execution is especially fast.
The code in the Main method is not particularly significant.
static void Main(string[] args)
{
// 5 threads read
for (int i = 0; i < 5; i++)
{
new Thread(() =>
{
while (true)
{
var result = DoSelect(1, MaxId);
if (result is null)
{
Console.WriteLine("Retrieval failed");
continue;
}
foreach (var item in result)
{
Console.Write($"{item.Id}|");
}
Console.WriteLine("\n");
Thread.Sleep(1000);
}
}).Start();
}
for (int i = 0; i < 2; i++)
{
new Thread(() =>
{
while (true)
{
var result = DoCreate((new Random().Next(0, 100)).ToString(), DateTime.Now); // Simulate order creation
if (result is null)
Console.WriteLine("Creation failed");
else Console.WriteLine("Creation succeeded");
}
}).Start();
}
}
In ASP.NET Core, the read-write lock can solve database read-write issues arising from multiple users sending HTTP requests simultaneously.
No example will be provided.
If another thread encounters an issue and cannot release the write lock for an extended period, it may lead to other threads waiting indefinitely.
To avoid prolonged blocking, use TryEnterWriteLock() with a specified wait time.
bool isGet = tool.TryEnterWriteLock(500);
Concurrent Dictionary Write Example
As this is a theoretical discussion, the author won't delve too deeply but will focus on mastering some API (methods, properties) usages through simple examples, and gradually explore the underlying principles.
Here, we will write an example of sharing a dictionary (Dictionary) in a multithreaded context.
Add two static variables:
private static ReaderWriterLockSlim toolLock = new ReaderWriterLockSlim();
private static Dictionary<int, string> dict = new Dictionary<int, string>();
Implement a write operation:
public static void Write(int key, int value)
{
try
{
// Upgrade state
toolLock.EnterUpgradeableReadLock();
// Read to check if it exists
if (dict.ContainsKey(key))
return;
try
{
// Enter write state
toolLock.EnterWriteLock();
dict.Add(key, value);
}
finally
{
toolLock.ExitWriteLock();
}
}
finally
{
toolLock.ExitUpgradeableReadLock();
}
}
The absence of catch { } statements above facilitates better code observation, as issues theoretically should not arise when using a read-write lock.
Simulating five threads writing to the dictionary simultaneously, due to the non-atomic nature of the operations, the value of sum may occasionally show repeated values.
For atomic operations, please refer to: https://www.cnblogs.com/whuanle/p/12724371.html#1，出现问题
private static int sum = 0;
public static void AddOne()
{
for (int i = 0; i < 1000; i++)
{
sum += 1;
}
}
static void Main(string[] args)
{
for (int i = 0; i < 5; i++)
{
new Thread(() => { AddOne(); }).Start();
}
Console.ReadKey();
}
ReaderWriterLock
In most cases, ReaderWriterLockSlim is recommended, and both have very similar usage methods.
For example, AcquireReaderLock acquires a read lock, and AcquireWriterLock acquires a write lock. Corresponding methods can simply replace examples in ReaderWriterLockSlim.
We won't elaborate on ReaderWriterLock further.
The common methods for ReaderWriterLock are as follows:
| Method | Description |
|------------------------------------|---------------------------------------------------------|
| AcquireReaderLock(Int32) | Acquires the read thread lock using an Int32 timeout value. |
| AcquireReaderLock(TimeSpan) | Acquires the read thread lock using a TimeSpan timeout value. |
| AcquireWriterLock(Int32) | Acquires the write thread lock using an Int32 timeout value. |
| AcquireWriterLock(TimeSpan) | Acquires the write thread lock using a TimeSpan timeout value. |
| AnyWritersSince(Int32) | Indicates whether a write thread lock has been granted to a thread since the acquisition sequence number. |
| DowngradeFromWriterLock(LockCookie) | Restores the thread's lock state to what it was before calling UpgradeToWriterLock(Int32). |
| ReleaseLock() | Releases the lock regardless of how many times the thread has obtained it. |
| ReleaseReaderLock() | Decreases the lock count for the reader lock. |
| ReleaseWriterLock() | Decreases the lock count for the writer lock. |
| RestoreLock(LockCookie) | Restores the thread's lock state to what it was before calling ReleaseLock(). |
| UpgradeToWriterLock(Int32) | Upgrades the read thread lock to a write thread lock using an Int32 timeout value. |
| UpgradeToWriterLock(TimeSpan) | Upgrades the read thread lock to a write thread lock using a TimeSpan timeout value. |
You can refer to the official examples at:
文章评论