[backend/core] Switch to lock objects for locking purposes

Iceshrimp.Backend/Core/Helpers/EventHelpers.cs

@@ -6,10 +6,11 @@ public sealed class AsyncAutoResetEvent(bool signaled = false)
 
 	private readonly List<TaskCompletionSource<bool>> _noResetTaskCompletionSources = [];
 	private readonly List<TaskCompletionSource<bool>> _taskCompletionSources        = [];
+	private readonly Lock                             _lock                         = new();
 
 	public Task<bool> WaitAsync(CancellationToken cancellationToken = default)
 	{
-		lock (_taskCompletionSources)
+		lock (_lock)
 		{
 			if (Signaled)
 			{
@@ -26,7 +27,7 @@ public sealed class AsyncAutoResetEvent(bool signaled = false)
 
 	public Task<bool> WaitWithoutResetAsync(CancellationToken cancellationToken = default)
 	{
-		lock (_taskCompletionSources)
+		lock (_lock)
 		{
 			if (Signaled)
 				return Task.FromResult(true);
@@ -40,7 +41,7 @@ public sealed class AsyncAutoResetEvent(bool signaled = false)
 
 	public void Set()
 	{
-		lock (_taskCompletionSources)
+		lock (_lock)
 		{
 			Signaled = true;
 			foreach (var tcs in _noResetTaskCompletionSources.ToList())
@@ -63,7 +64,7 @@ public sealed class AsyncAutoResetEvent(bool signaled = false)
 	private static void Callback(object? state)
 	{
 		var (ev, tcs) = ((AsyncAutoResetEvent, TaskCompletionSource<bool>))state!;
-		lock (ev._taskCompletionSources)
+		lock (ev._lock)
 		{
 			if (tcs.Task.IsCompleted) return;
 			tcs.TrySetCanceled();

Iceshrimp.Backend/Core/Helpers/WriteLockingHashSet.cs

@@ -7,19 +7,20 @@ namespace Iceshrimp.Backend.Core.Helpers;
                  Justification = "This is intentional (it's a *write* locking hash set, after all)")]
 public class WriteLockingHashSet<T>(IEnumerable<T>? sourceCollection = null) : ICollection<T>
 {
-	private readonly HashSet<T> _set = sourceCollection?.ToHashSet() ?? [];
+	private readonly HashSet<T> _set  = sourceCollection?.ToHashSet() ?? [];
+	private readonly Lock       _lock = new();
 
 	public IEnumerator<T>   GetEnumerator() => _set.GetEnumerator();
 	IEnumerator IEnumerable.GetEnumerator() => _set.GetEnumerator();
 
 	public void Add(T item)
 	{
-		lock (_set) _set.Add(item);
+		lock (_lock) _set.Add(item);
 	}
 
 	public void Clear()
 	{
-		lock (_set) _set.Clear();
+		lock (_lock) _set.Clear();
 	}
 
 	public bool Contains(T item) => _set.Contains(item);
@@ -28,7 +29,7 @@ public class WriteLockingHashSet<T>(IEnumerable<T>? sourceCollection = null) : I
 
 	public bool Remove(T item)
 	{
-		lock (_set) return _set.Remove(item);
+		lock (_lock) return _set.Remove(item);
 	}
 
 	public int  Count      => _set.Count;
@@ -36,18 +37,18 @@ public class WriteLockingHashSet<T>(IEnumerable<T>? sourceCollection = null) : I
 
 	public bool AddIfMissing(T item)
 	{
-		lock (_set) return _set.Add(item);
+		lock (_lock) return _set.Add(item);
 	}
 
 	public void AddRange(IEnumerable<T> items)
 	{
-		lock (_set)
+		lock (_lock)
 			foreach (var item in items)
 				_set.Add(item);
 	}
 
 	public int RemoveWhere(Predicate<T> predicate)
 	{
-		lock (_set) return _set.RemoveWhere(predicate);
+		lock (_lock) return _set.RemoveWhere(predicate);
 	}
 }

Iceshrimp.Backend/Core/Helpers/WriteLockingList.cs

@@ -8,18 +8,19 @@ namespace Iceshrimp.Backend.Core.Helpers;
 public class WriteLockingList<T>(IEnumerable<T>? sourceCollection = null) : ICollection<T>
 {
 	private readonly List<T> _list = sourceCollection?.ToList() ?? [];
+	private readonly Lock    _lock = new();
 
 	public IEnumerator<T>   GetEnumerator() => _list.GetEnumerator();
 	IEnumerator IEnumerable.GetEnumerator() => _list.GetEnumerator();
 
 	public void Add(T item)
 	{
-		lock (_list) _list.Add(item);
+		lock (_lock) _list.Add(item);
 	}
 
 	public void Clear()
 	{
-		lock (_list) _list.Clear();
+		lock (_lock) _list.Clear();
 	}
 
 	public bool Contains(T item) => _list.Contains(item);
@@ -28,7 +29,7 @@ public class WriteLockingList<T>(IEnumerable<T>? sourceCollection = null) : ICol
 
 	public bool Remove(T item)
 	{
-		lock (_list) return _list.Remove(item);
+		lock (_lock) return _list.Remove(item);
 	}
 
 	public int  Count      => _list.Count;
@@ -36,7 +37,7 @@ public class WriteLockingList<T>(IEnumerable<T>? sourceCollection = null) : ICol
 
 	public bool AddIfMissing(T item)
 	{
-		lock (_list)
+		lock (_lock)
 		{
 			if (_list.Contains(item)) return false;
 			_list.Add(item);
@@ -46,11 +47,11 @@ public class WriteLockingList<T>(IEnumerable<T>? sourceCollection = null) : ICol
 
 	public void AddRange(IEnumerable<T> item)
 	{
-		lock (_list) _list.AddRange(item);
+		lock (_lock) _list.AddRange(item);
 	}
 
 	public int RemoveAll(Predicate<T> predicate)
 	{
-		lock (_list) return _list.RemoveAll(predicate);
+		lock (_lock) return _list.RemoveAll(predicate);
 	}
 }