1 files changed, 304 insertions, 183 deletions
diff --git a/Emby.Common.Implementations/IO/SharpCifs/Util/Sharpen/Thread.cs b/Emby.Common.Implementations/IO/SharpCifs/Util/Sharpen/Thread.cs
index 59f3df469..9d874a0fa 100644
--- a/Emby.Common.Implementations/IO/SharpCifs/Util/Sharpen/Thread.cs
+++ b/Emby.Common.Implementations/IO/SharpCifs/Util/Sharpen/Thread.cs
@@ -1,193 +1,314 @@
+using SharpCifs.Util.DbsHelper;
 using System;
 using System.Collections.Generic;
+using System.Threading;
 
 namespace SharpCifs.Util.Sharpen
 {
     public class Thread : IRunnable
-	{
-		private static ThreadGroup _defaultGroup = new ThreadGroup ();
-		private bool _interrupted;
-		private IRunnable _runnable;
-		private ThreadGroup _tgroup;
-		private System.Threading.Thread _thread;
-		
-		[ThreadStatic]
-		private static Thread _wrapperThread;
-
-		public Thread () : this(null, null, null)
-		{
-		}
-
-		public Thread (string name) : this (null, null, name)
-		{
-		}
-
-		public Thread (ThreadGroup grp, string name) : this (null, grp, name)
-		{
-		}
-
-		public Thread (IRunnable runnable): this (runnable, null, null)
-		{
-		}
-		
-		Thread (IRunnable runnable, ThreadGroup grp, string name)
-		{
-			_thread = new System.Threading.Thread (InternalRun);
-			
-			this._runnable = runnable ?? this;
-			_tgroup = grp ?? _defaultGroup;
-			_tgroup.Add (this);
-			if (name != null)
-				_thread.Name = name;
-		}
-
-		private Thread (System.Threading.Thread t)
-		{
-			_thread = t;
-			_tgroup = _defaultGroup;
-			_tgroup.Add (this);
-		}
-
-		public static Thread CurrentThread ()
-		{
-			if (_wrapperThread == null) {
-				_wrapperThread = new Thread (System.Threading.Thread.CurrentThread);
-			}
-			return _wrapperThread;
-		}
-
-		public string GetName ()
-		{
-			return _thread.Name;
-		}
-
-		public ThreadGroup GetThreadGroup ()
-		{
-			return _tgroup;
-		}
-
-		private void InternalRun ()
-		{
-			_wrapperThread = this;
-			try {
-				_runnable.Run ();
-			} catch (Exception exception) {
-				Console.WriteLine (exception);
-			} finally {
-				_tgroup.Remove (this);
-			}
-		}
-		
-		public static void Yield ()
-		{
-		}
-
-		public void Interrupt ()
-		{
-			lock (_thread) {
-				_interrupted = true;
-                //thread.Interrupt ();
-
-                //TODO: implement CancellationToken 
-                //_thread.Abort();
-                throw new NotImplementedException("implement CancellationToken for thread");
+    {
+        private static ThreadGroup DefaultGroup = new ThreadGroup();
+
+        [ThreadStatic]
+        private static Thread WrapperThread;
+
+        public static Thread CurrentThread()
+        {
+            if (Thread.WrapperThread == null)
+            {
+                Thread.WrapperThread = new Thread(System.Environment.CurrentManagedThreadId);
+            }
+
+            return Thread.WrapperThread;
+        }
+
+
+        public CancellationTokenSource Canceller => this._canceller;
+
+        public bool IsCanceled
+        {
+            get
+            {
+                if (this._canceller?.IsCancellationRequested == true
+                    && !this._isCanceled)
+                {
+                    this._isCanceled = true;
+                }
+
+                return this._isCanceled;
+            }
+        }
+
+        private IRunnable _runnable;
+        private ThreadGroup _tgroup;
+        private System.Threading.Tasks.Task _task = null;
+        private CancellationTokenSource _canceller = null;
+
+        private string _name = string.Empty;
+        private bool _isBackground = true;
+        private bool _interrupted = false;
+        private int? _id = null;
+        private bool _isRunning = false;
+        private bool _isCanceled = false;
+
+
+
+        public Thread() : this(null, null, null)
+        {
+        }
+
+
+        public Thread(string name) : this(null, null, name)
+        {
+        }
+
+
+        public Thread(ThreadGroup grp, string name) : this(null, grp, name)
+        {
+        }
+
+
+        public Thread(IRunnable runnable) : this(runnable, null, null)
+        {
+        }
+
+
+        private Thread(IRunnable runnable, ThreadGroup grp, string name)
+        {
+            this._runnable = runnable ?? this;
+            this._tgroup = grp ?? DefaultGroup;
+            this._tgroup.Add(this);
+
+            if (name != null)
+            {
+                this._name = name;
+            }
+        }
+
+
+        private Thread(int threadId)
+        {
+            this._id = threadId;
+
+            this._tgroup = DefaultGroup;
+            this._tgroup.Add(this);
+        }
+        
+
+        public string GetName()
+        {
+            return this._name;
+        }
+
+
+        public ThreadGroup GetThreadGroup()
+        {
+            return this._tgroup;
+        }
+
+
+        public static void Yield()
+        {
+        }
+
+
+        public void Interrupt()
+        {
+            this._interrupted = true;
+            this._canceller?.Cancel(true);
+        }
+
+
+        public static bool Interrupted()
+        {
+            if (Thread.WrapperThread == null)
+            {
+                return false;
+            }
+
+            Thread wrapperThread = Thread.WrapperThread;
+            lock (wrapperThread)
+            {
+                bool interrupted = Thread.WrapperThread._interrupted;
+                Thread.WrapperThread._interrupted = false;
+                return interrupted;
+            }
+        }
+
+
+        public bool IsAlive()
+        {
+            if (this._task == null)
+                return true; //実行されていない
+
+            //Taskが存在し、続行中のときtrue
+            return (!this._task.IsCanceled
+                    && !this._task.IsFaulted
+                    && !this._task.IsCompleted);
+        }
+
+
+        public void Join()
+        {
+            this._task?.Wait();
+        }
+
+
+        public void Join(long timeout)
+        {
+            this._task?.Wait((int) timeout);
+        }
+
+
+        public virtual void Run()
+        {
+        }
+
+
+        public void SetDaemon(bool daemon)
+        {
+            this._isBackground = daemon;
+        }
+
+
+        public void SetName(string name)
+        {
+            this._name = name;
+        }
+
+
+        public static void Sleep(long milis)
+        {
+            System.Threading.Tasks.Task.Delay((int) milis).Wait();
+        }
+
+
+        public void Start(bool isSynced = false)
+        {
+            if (this._isRunning)
+                throw new InvalidOperationException("Thread Already started.");
+
+            this._canceller = new CancellationTokenSource();
+            
+            this._task = System.Threading.Tasks.Task.Run(() =>
+            {
+                Thread.WrapperThread = this;
+                this._id = System.Environment.CurrentManagedThreadId;
+
+                //Log.Out("Thread.Start - Task Start");
+                this._isRunning = true;
+                
+                try
+                {
+                    this._runnable.Run();
+                    //Log.Out("Thread.Start - Task Normaly End");
+                }
+                catch (Exception exception)
+                {
+                    //Log.Out("Thread.Start - Task Error End");
+                    Console.WriteLine(exception);
+                }
+                finally
+                {
+                    this._isRunning = false;
+
+                    this._tgroup?.Remove(this);
+
+                    this._canceller?.Dispose();
+                    this._canceller = null;
+
+                    //Log.Out("Thread.Start - Task Close Completed");
+                }
+            }, this._canceller.Token);
+
+            //同期的に実行するとき、動作中フラグONまで待つ。
+            if (isSynced)
+                while (!this._isRunning)
+                    System.Threading.Tasks.Task.Delay(300).GetAwaiter().GetResult();
+        }
+
+
+        public void Cancel(bool isSynced = false)
+        {
+            //Log.Out("Thread.Cancel");
+
+            this._isCanceled = true;
+            this._canceller?.Cancel(true);
+
+            //同期的に実行するとき、動作中フラグOFFまで待つ。
+            if (isSynced)
+                while (this._isRunning)
+                    System.Threading.Tasks.Task.Delay(300).GetAwaiter().GetResult();
+        }
+
+
+        public bool Equals(Thread thread)
+        {
+            //渡し値スレッドがnullのとき、合致しない
+            if (thread == null)
+                return false;
+
+            //自身か渡し値スレッドの、スレッドIDが取得出来ていない(=スレッド未生成)
+            //　→合致しない
+            if (this._id == null
+                || thread._id == null)
+                return false;
+
+            return (this._id == thread._id);
+        }
+
+
+        public void Dispose()
+        {
+            //Log.Out("Thread.Dispose");
+
+            this._runnable = null;
+            this._tgroup = null;
+            this._task = null;
+            this._canceller?.Dispose();
+            this._canceller = null;
+            this._name = null;
+            this._isRunning = false;
+            this._id = null;
+        }
+    }
+
+    public class ThreadGroup
+    {
+        private List<Thread> _threads = new List<Thread>();
+
+        public ThreadGroup()
+        {
+        }
+
+        public ThreadGroup(string name)
+        {
+        }
+
+        internal void Add(Thread t)
+        {
+            lock (_threads)
+            {
+                _threads.Add(t);
+            }
+        }
+
+        internal void Remove(Thread t)
+        {
+            lock (_threads)
+            {
+                _threads.Remove(t);
             }
         }
 
-		public static bool Interrupted ()
-		{
-			if (Thread._wrapperThread == null) {
-				return false;
-			}
-			Thread wrapperThread = Thread._wrapperThread;
-			lock (wrapperThread) {
-				bool interrupted = Thread._wrapperThread._interrupted;
-				Thread._wrapperThread._interrupted = false;
-				return interrupted;
-			}
-		}
-
-		public bool IsAlive ()
-		{
-			return _thread.IsAlive;
-		}
-
-		public void Join ()
-		{
-			_thread.Join ();
-		}
-
-		public void Join (long timeout)
-		{
-			_thread.Join ((int)timeout);
-		}
-
-		public virtual void Run ()
-		{
-		}
-
-		public void SetDaemon (bool daemon)
-		{
-			_thread.IsBackground = daemon;
-		}
-
-		public void SetName (string name)
-		{
-			_thread.Name = name;
-		}
-
-		public static void Sleep (long milis)
-		{
-			System.Threading.Thread.Sleep ((int)milis);
-		}
-
-		public void Start ()
-		{
-			_thread.Start ();
-		}
-		
-		public void Abort ()
-		{
-            //TODO: implement CancellationToken 
-            //_thread.Abort ();
-            throw new NotImplementedException("implement CancellationToken for thread");
-        }
-		
-	}
-
-	public class ThreadGroup
-	{
-		private List<Thread> _threads = new List<Thread> ();
-		
-		public ThreadGroup()
-		{
-		}
-		
-		public ThreadGroup (string name)
-		{
-		}
-
-		internal void Add (Thread t)
-		{
-			lock (_threads) {
-				_threads.Add (t);
-			}
-		}
-		
-		internal void Remove (Thread t)
-		{
-			lock (_threads) {
-				_threads.Remove (t);
-			}
-		}
-
-		public int Enumerate (Thread[] array)
-		{
-			lock (_threads) {
-				int count = Math.Min (array.Length, _threads.Count);
-				_threads.CopyTo (0, array, 0, count);
-				return count;
-			}
-		}
-	}
+        public int Enumerate(Thread[] array)
+        {
+            lock (_threads)
+            {
+                int count = Math.Min(array.Length, _threads.Count);
+                _threads.CopyTo(0, array, 0, count);
+                return count;
+            }
+        }
+    }
 }