- Initial commit

2026-07-03 05:02:26 +03:00
commit 374ff1e689
4080 changed files with 388870 additions and 0 deletions
--- a/Runtime/Shared/PlatformSupport/Threading/ThreadedRunner.cs
+++ b/Runtime/Shared/PlatformSupport/Threading/ThreadedRunner.cs
@ -0,0 +1,165 @@
+#define _USE_CUSTOM_THREADPOOL
+using System;
+using System.Threading;
+
+namespace Best.HTTP.Shared.PlatformSupport.Threading
+{
+    [IL2CPP.Il2CppEagerStaticClassConstruction]
+    public static class ThreadedRunner
+    {
+        public static int ShortLivingThreads { get => _shortLivingThreads; }
+        private static int _shortLivingThreads;
+
+        public static int LongLivingThreads { get => _LongLivingThreads; }
+        private static int _LongLivingThreads;
+
+        public static void SetThreadName(string name)
+        {
+            try
+            {
+                System.Threading.Thread.CurrentThread.Name = name;
+            }
+            catch(Exception ex)
+            {
+                if (HTTPManager.Logger.IsDiagnostic)
+                    HTTPManager.Logger.Exception(nameof(ThreadedRunner), nameof(SetThreadName), ex);
+            }
+        }
+
+        public static void RunShortLiving<T>(Action<T> job, T param)
+        {
+            #if USE_CUSTOM_THREADPOOL
+            CustomThreadPool.QueueUserWorkItem(() =>
+            #else
+            ThreadPool.QueueUserWorkItem((state) =>
+            #endif
+            {
+                using var __ = new IncDecShortLiving(true);
+                job(param);
+            });
+        }
+
+        public static void RunShortLiving<T1, T2>(Action<T1, T2> job, T1 param1, T2 param2)
+        {
+#if USE_CUSTOM_THREADPOOL
+            CustomThreadPool.QueueUserWorkItem(() =>
+#else
+            ThreadPool.QueueUserWorkItem((state) =>
+#endif
+            {
+                using var __ = new IncDecShortLiving(true);
+                job(param1, param2);
+            });
+        }
+
+        public static void RunShortLiving<T1, T2, T3>(Action<T1, T2, T3> job, T1 param1, T2 param2, T3 param3)
+        {            
+#if USE_CUSTOM_THREADPOOL
+            CustomThreadPool.QueueUserWorkItem(() =>
+#else
+            ThreadPool.QueueUserWorkItem((state) =>
+#endif
+            {
+                using var __ = new IncDecShortLiving(true);
+                job(param1, param2, param3);
+            });
+        }
+
+        public static void RunShortLiving<T1, T2, T3, T4>(Action<T1, T2, T3, T4> job, T1 param1, T2 param2, T3 param3, T4 param4)
+        {
+#if USE_CUSTOM_THREADPOOL
+            CustomThreadPool.QueueUserWorkItem(() =>
+#else
+            ThreadPool.QueueUserWorkItem((state) =>
+#endif
+            {
+                using var __ = new IncDecShortLiving(true);
+                job(param1, param2, param3, param4);
+            });
+        }
+
+        public static void RunShortLiving(Action job)
+        {
+#if USE_CUSTOM_THREADPOOL
+            CustomThreadPool.QueueUserWorkItem(() =>
+#else
+            ThreadPool.QueueUserWorkItem((state) =>
+#endif
+            {
+                using var __ = new IncDecShortLiving(true);
+                job();
+            });
+        }
+
+        public static Thread RunLongLiving(Action job)
+        {
+            var thread = new Thread(() =>
+            {
+                using var __ = new IncDecLongLiving(true);
+                job();
+            });
+            thread.IsBackground = true;
+            thread.Start();
+
+            return thread;
+        }
+        
+        private static int maxLongLiving;
+        private static int maxShortLiving;
+        
+        public static void StoreLongLivingThreadUsage(int count)
+        {
+            int current;
+            do
+            {
+                current = maxLongLiving;
+            } while (current < count && Interlocked.CompareExchange(ref maxLongLiving, count, current) != current);
+        }
+
+        public static int GetAndZeroLongLivingThreadUsage()
+        {
+            int current = maxLongLiving;
+            Interlocked.Exchange(ref maxLongLiving, 0);
+            return current;
+        }
+
+        public static int GetAndZeroShortLivingThreadUsage()
+        {
+            int current = maxShortLiving;
+            Interlocked.Exchange(ref maxShortLiving, 0);
+            return current;
+        }
+
+
+        public static void StoreShortLivingThreadUsage(int count)
+        {
+            int current;
+            do
+            {
+                current = maxShortLiving;
+            } while (current < count && Interlocked.CompareExchange(ref maxShortLiving, count, current) != current);
+        }
+
+        public struct IncDecShortLiving : IDisposable
+        {
+            public IncDecShortLiving(bool dummy) => Interlocked.Increment(ref ThreadedRunner._shortLivingThreads);
+
+            public void Dispose()
+            {
+                StoreShortLivingThreadUsage(ThreadedRunner._shortLivingThreads);
+                Interlocked.Decrement(ref ThreadedRunner._shortLivingThreads);
+            }
+        }
+
+        public struct IncDecLongLiving : IDisposable
+        {
+            public IncDecLongLiving(bool dummy) => Interlocked.Increment(ref ThreadedRunner._LongLivingThreads);
+
+            public void Dispose()
+            {
+                StoreLongLivingThreadUsage(ThreadedRunner._LongLivingThreads);
+                Interlocked.Decrement(ref ThreadedRunner._LongLivingThreads);
+            }
+        }
+    }
+}