optimize tasks

Pixiview/Illust/IllustCollectionPage.cs

@@ -75,6 +75,7 @@ namespace Pixiview.Illust
         protected double topOffset;
 
         private T illustData;
+        private ParallelTask task;
 
         public IllustCollectionPage()
         {
@@ -95,6 +96,11 @@ namespace Pixiview.Illust
 
         public override void OnUnload()
         {
+            if (task != null)
+            {
+                task.Dispose();
+                task = null;
+            }
             InvalidateCollection();
             Illusts = null;
             lastUpdated = default;
@@ -559,7 +565,12 @@ namespace Pixiview.Illust
 
         void DoLoadImages(IllustCollection collection)
         {
-            ParallelTask.Start(0, collection.Count, Configs.MaxThreads, i =>
+            if (task != null)
+            {
+                task.Dispose();
+                task = null;
+            }
+            task = ParallelTask.Start(0, collection.Count, Configs.MaxThreads, i =>
             {
                 if (!collection.Running)
                 {
@@ -716,11 +727,17 @@ namespace Pixiview.Illust
         }
 
         private readonly object sync = new object();
-        private volatile bool running;
+        private bool running;
 
         public bool Running
         {
-            get => running;
+            get
+            {
+                lock (sync)
+                {
+                    return running;
+                }
+            }
             set
             {
                 lock (sync)

Pixiview/Illust/UserIllustPage.xaml.cs

@@ -109,13 +109,6 @@ namespace Pixiview.Illust
                 return;
             }
             await ScrollToTopAsync(scrollView);
-            // release
-            var collection = IllustCollection;
-            if (collection != null)
-            {
-                collection.Running = false;
-                IllustCollection = null;
-            }
             startIndex = -1;
             nextIndex = 0;
             illustIds = null;

Pixiview/Illust/ViewIllustPage.xaml.cs

@@ -128,6 +128,7 @@ namespace Pixiview.Illust
         private readonly ImageSource fontIconNotLove;
         private IllustUgoiraData ugoiraData;
         private Ugoira ugoira;
+        private ParallelTask task;
 
         private readonly object sync = new object();
         private int downloaded = 0;
@@ -188,6 +189,15 @@ namespace Pixiview.Illust
             }
         }
 
+        public override void OnUnload()
+        {
+            if (task != null)
+            {
+                task.Dispose();
+                task = null;
+            }
+        }
+
 #if __IOS__
         protected override void OnPageTopMarginChanged(Thickness old, Thickness @new)
         {
@@ -387,7 +397,12 @@ namespace Pixiview.Illust
                 }
             }
 
-            ParallelTask.Start(0, items.Length, Configs.MaxPageThreads, i =>
+            if (task != null)
+            {
+                task.Dispose();
+                task = null;
+            }
+            task = ParallelTask.Start(0, items.Length, Configs.MaxPageThreads, i =>
             {
                 DoLoadImage(i);
                 return true;
@@ -461,7 +476,6 @@ namespace Pixiview.Illust
             else
             {
                 var val = downloaded / (float)pageCount;
-                App.DebugPrint($"download progress: {val}");
                 MainThread.BeginInvokeOnMainThread(() =>
                 {
                     ViewExtensions.CancelAnimations(progress);

Pixiview/UI/AdaptedPage.cs

@@ -153,7 +153,7 @@ namespace Pixiview.UI
                 return _instance;
             }
 
-            private volatile bool isBusy = false;
+            private bool isBusy = false;
 
             public void Dispose()
             {

Pixiview/Utils/Extensions.cs

@@ -93,16 +93,18 @@ namespace Pixiview.Utils
         }
     }
 
-    public class ParallelTask
+    public class ParallelTask : IDisposable
     {
-        public static void Start(int from, int toExclusive, int maxCount, Predicate<int> action)
+        public static ParallelTask Start(int from, int toExclusive, int maxCount, Predicate<int> action)
         {
             var task = new ParallelTask(from, toExclusive, maxCount, action);
             Task.Run(task.Start);
+            return task;
         }
 
-        private volatile int count;
+        private readonly object sync = new object();
-        private volatile bool disposed;
+        private int count;
+        private bool disposed;
 
         private readonly int max;
         private readonly int from;
@@ -130,7 +132,12 @@ namespace Pixiview.Utils
             for (int i = from; i < to; i++)
             {
                 var index = i;
-                while (count >= max)
+                bool flag;
+                lock (sync)
+                {
+                    flag = count >= max;
+                }
+                while (flag)
                 {
                     if (disposed)
                     {
@@ -139,27 +146,44 @@ namespace Pixiview.Utils
                     }
                     Thread.Sleep(100);
                 }
+                lock (sync)
+                {
                     count++;
+                }
                 Task.Run(() =>
                 {
                     try
                     {
                         if (!action(index))
+                        {
+                            lock (sync)
                             {
                                 disposed = true;
                             }
                         }
+                    }
                     catch (Exception ex)
                     {
                         App.DebugError("parallel.start", $"failed to run action, index: {i}, error: {ex.Message}");
                     }
                     finally
+                    {
+                        lock (sync)
                         {
                             count--;
                         }
+                    }
                 });
             }
         }
+
+        public void Dispose()
+        {
+            lock (sync)
+            {
+                disposed = true;
+            }
+        }
     }
 
     public static class Screen

Pixiview/Utils/Stores.cs

@@ -32,8 +32,6 @@ namespace Pixiview.Utils
         private const string userFolder = "user-profile";
         private const string recommendsFolder = "recommends";
 
-        private static readonly object sync = new object();
-
         public static bool NetworkAvailable
         {
             get
@@ -56,8 +54,6 @@ namespace Pixiview.Utils
         private static IllustFavorite favoriteObject;
 
         public static IllustFavorite GetFavoriteObject(bool force = false)
-        {
-            lock (sync)
         {
             if (force || favoriteObject == null)
             {
@@ -76,7 +72,6 @@ namespace Pixiview.Utils
             }
             return favoriteObject;
         }
-        }
 
         public static IllustFavorite LoadFavoritesIllusts(string file = null)
         {
@@ -84,22 +79,16 @@ namespace Pixiview.Utils
             {
                 file = FavoritesPath;
             }
-            lock (sync)
-            {
             return ReadObject<IllustFavorite>(file);
         }
-        }
 
         public static void SaveFavoritesIllusts()
         {
             var file = FavoritesPath;
-            lock (sync)
-            {
             var data = GetFavoriteObject();
             data.LastFavoriteUtc = DateTime.UtcNow;
             WriteObject(file, data);
         }
-        }
 
         public static string LoadUgoiraImage(string zip, string frame)
         {