Merge pull request #21 from dotnet-campus/t/lindexi/KobarwhawcileNaicewhefai

加上双缓存

Author: kkwpsv

AsyncWorkerCollection/AsyncWorkerCollection.csproj

@@ -4,6 +4,7 @@
         <TargetFrameworks>net45;netcoreapp3.1</TargetFrameworks>
         <RootNamespace>dotnetCampus.Threading</RootNamespace>
         <GeneratePackageOnBuild>true</GeneratePackageOnBuild>
+        <GenerateDocumentationFile>true</GenerateDocumentationFile>
         <AssemblyName>dotnetCampus.AsyncWorkerCollection</AssemblyName>
     </PropertyGroup>
 

AsyncWorkerCollection/AsyncWorkerCollection.csproj.DotSettings

@@ -1,2 +1,3 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
-	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=asynctaskqueue_005F/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=asynctaskqueue_005F/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/CodeInspection/NamespaceProvider/NamespaceFoldersToSkip/=doublebuffer_005F/@EntryIndexedValue">True</s:Boolean></wpf:ResourceDictionary>

AsyncWorkerCollection/DoubleBuffer_/DoubleBuffer.cs

@@ -0,0 +1,101 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace dotnetCampus.Threading
+{
+    /// <summary>
+    /// 提供双缓存 线程安全列表
+    /// </summary>
+    /// <typeparam name="T">用于存放 <typeparamref name="TU"/> 的集合</typeparam>
+    /// <typeparam name="TU"></typeparam>
+    /// 写入的时候写入到一个列表，通过 SwitchBuffer 方法，可以切换当前缓存
+    public class DoubleBuffer<T, TU> where T : class, ICollection<TU>
+    {
+        /// <summary>
+        /// 创建双缓存
+        /// </summary>
+        /// <param name="aList"></param>
+        /// <param name="bList"></param>
+        public DoubleBuffer(T aList, T bList)
+        {
+            AList = aList;
+            BList = bList;
+
+            CurrentList = AList;
+        }
+
+        /// <summary>
+        /// 加入元素到缓存
+        /// </summary>
+        /// <param name="t"></param>
+        public void Add(TU t)
+        {
+            lock (_lock)
+            {
+                CurrentList.Add(t);
+            }
+        }
+
+        /// <summary>
+        /// 切换缓存
+        /// </summary>
+        /// <returns></returns>
+        public T SwitchBuffer()
+        {
+            lock (_lock)
+            {
+                if (ReferenceEquals(CurrentList, AList))
+                {
+                    CurrentList = BList;
+                    return AList;
+                }
+                else
+                {
+                    CurrentList = AList;
+                    return BList;
+                }
+            }
+        }
+
+        /// <summary>
+        /// 执行完所有任务
+        /// </summary>
+        /// <param name="action">当前缓存里面存在的任务，请不要保存传入的 List 参数</param>
+        public void DoAll(Action<T> action)
+        {
+            while (true)
+            {
+                var buffer = SwitchBuffer();
+                if (buffer.Count == 0) break;
+
+                action(buffer);
+                buffer.Clear();
+            }
+        }
+
+        /// <summary>
+        /// 执行完所有任务
+        /// </summary>
+        /// <param name="action">当前缓存里面存在的任务，请不要保存传入的 List 参数</param>
+        /// <returns></returns>
+        public async Task DoAllAsync(Func<T, Task> action)
+        {
+            while (true)
+            {
+                var buffer = SwitchBuffer();
+                if (buffer.Count == 0) break;
+
+                await action(buffer);
+                buffer.Clear();
+            }
+        }
+
+        private readonly object _lock = new object();
+
+        private T CurrentList { set; get; }
+
+        private T AList { get; }
+        private T BList { get; }
+    }
+}

AsyncWorkerCollection/DoubleBuffer_/DoubleBufferTask.cs

@@ -0,0 +1,108 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+#if NETFRAMEWORK
+using ValueTask = System.Threading.Tasks.Task;
+#endif
+
+namespace dotnetCampus.Threading
+{
+    /// <summary>
+    /// 双缓存任务
+    /// </summary>
+    public class DoubleBufferTask<T, TU> : IAsyncDisposable
+        where T : class, ICollection<TU>
+    {
+        /// <summary>
+        /// 创建双缓存任务，执行任务的方法放在 <paramref name="doTask"/> 方法
+        /// </summary>
+        /// <param name="doTask">
+        /// 执行任务的方法
+        /// <para></para>
+        /// 传入的 List&lt;T&gt; 就是需要执行的任务，请不要将传入的 List&lt;T&gt; 保存到本地字段
+        /// </param>
+        /// <param name="aList"></param>
+        /// <param name="bList"></param>
+        public DoubleBufferTask(T aList, T bList, Func<T, Task> doTask)
+        {
+            _doTask = doTask;
+            DoubleBuffer = new DoubleBuffer<T, TU>(aList, bList);
+        }
+
+        /// <summary>
+        /// 加入任务
+        /// </summary>
+        /// <param name="t"></param>
+        public void AddTask(TU t)
+        {
+            DoubleBuffer.Add(t);
+
+            DoInner();
+        }
+
+        private async void DoInner()
+        {
+            // ReSharper disable once InconsistentlySynchronizedField
+            if (_isDoing) return;
+
+            lock (DoubleBuffer)
+            {
+                if (_isDoing) return;
+                _isDoing = true;
+            }
+
+            await DoubleBuffer.DoAllAsync(_doTask);
+
+            lock (DoubleBuffer)
+            {
+                _isDoing = false;
+                Finished?.Invoke(this, EventArgs.Empty);
+            }
+        }
+
+        /// <summary>
+        /// 完成任务
+        /// </summary>
+        public void Finish()
+        {
+            lock (DoubleBuffer)
+            {
+                if (!_isDoing)
+                {
+                    FinishTask.SetResult(true);
+                    return;
+                }
+
+                Finished += (sender, args) => FinishTask.SetResult(true);
+            }
+        }
+
+        /// <summary>
+        /// 等待完成任务，只有在调用 <see cref="Finish"/> 之后，所有任务执行完成才能完成
+        /// </summary>
+        /// <returns></returns>
+        public Task WaitAllTaskFinish()
+        {
+            return FinishTask.Task;
+        }
+
+        private TaskCompletionSource<bool> FinishTask { get; } = new TaskCompletionSource<bool>();
+
+        private bool _isDoing;
+
+        private event EventHandler? Finished;
+
+        private readonly Func<T, Task> _doTask;
+
+        private DoubleBuffer<T, TU> DoubleBuffer { get; }
+
+        /// <inheritdoc />
+        public async ValueTask DisposeAsync()
+        {
+            Finish();
+            await WaitAllTaskFinish();
+        }
+    }
+}

AsyncWorkerCollection/DoubleBuffer_/DoubleBufferTask`T.cs

@@ -0,0 +1,22 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace dotnetCampus.Threading
+{
+    /// <summary>
+    /// 双缓存任务
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public class DoubleBufferTask<T> : DoubleBufferTask<List<T>, T>
+    {
+        /// <summary>
+        /// 创建双缓存任务，执行任务的方法放在 <paramref name="doTask"/> 方法
+        /// </summary>
+        /// <param name="doTask"></param>
+        public DoubleBufferTask(Func<List<T>, Task> doTask) : base(new List<T>(), new List<T>(), doTask)
+        {
+        }
+    }
+}

AsyncWorkerCollection/DoubleBuffer_/DoubleBuffer`T.cs

@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+
+namespace dotnetCampus.Threading
+{
+    /// <summary>
+    /// 提供双缓存 线程安全列表
+    /// </summary>
+    /// 写入的时候写入到一个列表，通过 SwitchBuffer 方法，可以切换当前缓存
+    public class DoubleBuffer<T> : DoubleBuffer<List<T>, T>
+    {
+        /// <summary>
+        /// 创建使用 <see cref="List&lt;T&gt;"/> 的双缓存
+        /// </summary>
+        public DoubleBuffer() : base(new List<T>(), new List<T>())
+        {
+        }
+    }
+}

AsyncWorkerCollection/IAsyncDisposable.cs

@@ -4,10 +4,15 @@
 using System.Text;
 using System.Threading.Tasks;
 
+#if NETFRAMEWORK
+using ValueTask = System.Threading.Tasks.Task;
+#endif
+
 namespace dotnetCampus.Threading
 {
     // 这个接口在 .NET Framework 4.5 没有
     interface IAsyncDisposable
     {
+        ValueTask DisposeAsync();
     }
 }