Remove XThread as obsolete

nayato · nayato · commit 05e5aa40c3b1 · 2021-07-19T16:55:44.000-07:00
diff --git a/src/DotNetty.Buffers/PoolThreadCache.cs b/src/DotNetty.Buffers/PoolThreadCache.cs
@@ -6,10 +6,10 @@ namespace DotNetty.Buffers
     using System;
     using System.Diagnostics;
     using System.Diagnostics.Contracts;
+    using System.Threading;
     using DotNetty.Common;
     using DotNetty.Common.Internal;
     using DotNetty.Common.Internal.Logging;
-    using Thread = DotNetty.Common.Concurrency.XThread;
 
     /// <summary>
     ///     Acts a Thread cache for allocations. This implementation is moduled after
diff --git a/src/DotNetty.Common/Concurrency/AbstractEventExecutor.cs b/src/DotNetty.Common/Concurrency/AbstractEventExecutor.cs
@@ -8,7 +8,6 @@ namespace DotNetty.Common.Concurrency
     using System.Threading;
     using System.Threading.Tasks;
     using DotNetty.Common.Internal.Logging;
-    using Thread = XThread;
 
     /// <summary>
     ///     Abstract base class for <see cref="IEventExecutor" /> implementations
diff --git a/src/DotNetty.Common/Concurrency/IEventExecutor.cs b/src/DotNetty.Common/Concurrency/IEventExecutor.cs
@@ -3,8 +3,8 @@
 
 namespace DotNetty.Common.Concurrency
 {
-    using Thread = DotNetty.Common.Concurrency.XThread;
-
+    using System.Threading;
+ 
     public interface IEventExecutor : IEventExecutorGroup
     {
         /// <summary>
diff --git a/src/DotNetty.Common/Concurrency/SingleThreadEventExecutor.cs b/src/DotNetty.Common/Concurrency/SingleThreadEventExecutor.cs
@@ -12,7 +12,6 @@ namespace DotNetty.Common.Concurrency
     using System.Threading.Tasks;
     using DotNetty.Common.Internal;
     using DotNetty.Common.Internal.Logging;
-    using Thread = XThread;
 
     /// <summary>
     /// <see cref="IEventExecutor"/> backed by a single thread.
diff --git a/src/DotNetty.Common/Concurrency/XThread.cs b/src/DotNetty.Common/Concurrency/XThread.cs
diff --git a/src/DotNetty.Common/ThreadDeathWatcher.cs b/src/DotNetty.Common/ThreadDeathWatcher.cs
@@ -10,7 +10,6 @@ namespace DotNetty.Common
     using DotNetty.Common.Concurrency;
     using DotNetty.Common.Internal;
     using DotNetty.Common.Internal.Logging;
-    using Thread = DotNetty.Common.Concurrency.XThread;
 
     public static class ThreadDeathWatcher
     {
diff --git a/src/DotNetty.Common/ThreadLocalPool.cs b/src/DotNetty.Common/ThreadLocalPool.cs
@@ -10,7 +10,6 @@ namespace DotNetty.Common
     using System.Diagnostics.Contracts;
     using System.Runtime.CompilerServices;
     using System.Threading;
-    using Thread = DotNetty.Common.Concurrency.XThread;
 
     public class ThreadLocalPool
     {
diff --git a/src/DotNetty.Common/Utilities/HashedWheelTimer.cs b/src/DotNetty.Common/Utilities/HashedWheelTimer.cs
@@ -27,7 +27,7 @@ public sealed class HashedWheelTimer : ITimer
         const int InstanceCountLimit = 64;
 
         readonly Worker worker;
-        readonly XThread workerThread;
+        readonly Thread workerThread;
         readonly CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();
 
         const int WorkerStateInit = 0;
@@ -98,7 +98,7 @@ public HashedWheelTimer(
                         tickInterval,
                         long.MaxValue / this.wheel.Length));
             }
-            this.workerThread = new XThread(st => this.worker.Run());
+            this.workerThread = new Thread(st => this.worker.Run());
 
             this.maxPendingTimeouts = maxPendingTimeouts;
 
@@ -187,7 +187,7 @@ public async Task<ISet<ITimeout>> StopAsync()
         {
             GC.SuppressFinalize(this);
 
-            if (XThread.CurrentThread == this.workerThread)
+            if (Thread.CurrentThread == this.workerThread)
             {
                 throw new InvalidOperationException($"{nameof(HashedWheelTimer)}.stop() cannot be called from timer task.");
             }
diff --git a/src/DotNetty.Common/Utilities/ReferenceCountUtil.cs b/src/DotNetty.Common/Utilities/ReferenceCountUtil.cs
@@ -6,7 +6,6 @@ namespace DotNetty.Common.Utilities
     using System;
     using System.Threading;
     using DotNetty.Common.Internal.Logging;
-    using Thread = DotNetty.Common.Concurrency.XThread;
 
     public static class ReferenceCountUtil
     {
diff --git a/src/DotNetty.Common/Utilities/ThreadExtensions.cs b/src/DotNetty.Common/Utilities/ThreadExtensions.cs
@@ -6,7 +6,6 @@ namespace DotNetty.Common.Utilities
     using System;
     using System.Diagnostics.Contracts;
     using System.Threading;
-    using Thread = DotNetty.Common.Concurrency.XThread;
 
     public static class ThreadExtensions
     {
diff --git a/src/DotNetty.Transport.Libuv/EventLoopGroup.cs b/src/DotNetty.Transport.Libuv/EventLoopGroup.cs
@@ -74,7 +74,7 @@ public EventLoopGroup(int eventLoopCount)
         public override IEventExecutor GetNext()
         {
             // Attempt to select event loop based on thread first
-            int threadId = XThread.CurrentThread.Id;
+            int threadId = Thread.CurrentThread.ManagedThreadId;
             int i;
             for (i = 0; i < this.eventLoops.Length; i++)
             {
diff --git a/src/DotNetty.Transport.Libuv/LoopExecutor.cs b/src/DotNetty.Transport.Libuv/LoopExecutor.cs
@@ -36,7 +36,7 @@ class LoopExecutor : AbstractScheduledEventExecutor
         readonly ThreadLocalPool<WriteRequest> writeRequestPool = new ThreadLocalPool<WriteRequest>(handle => new WriteRequest(handle));
         readonly long preciseBreakoutInterval;
         readonly IQueue<IRunnable> taskQueue;
-        readonly XThread thread;
+        readonly Thread thread;
         readonly TaskScheduler scheduler;
         readonly ManualResetEventSlim loopRunStart;
         readonly TaskCompletionSource terminationCompletionSource;
@@ -80,7 +80,7 @@ public LoopExecutor(IEventLoopGroup parent, string threadName, TimeSpan breakout
             {
                 name = $"{name}({threadName})";
             }
-            this.thread = new XThread(Run) { Name = name };
+            this.thread = new Thread(Run) { Name = name };
             this.loopRunStart = new ManualResetEventSlim(false, 1);
         }
 
@@ -97,7 +97,7 @@ protected void Start()
 
         internal Loop UnsafeLoop => this.loop;
 
-        internal int LoopThreadId => this.thread.Id;
+        internal int LoopThreadId => this.thread.ManagedThreadId;
 
         static void Run(object state)
         {
@@ -424,7 +424,7 @@ static IRunnable PollTaskFrom(IQueue<IRunnable> taskQueue) =>
 
         public override bool IsTerminated => this.executionState == TerminatedState;
 
-        public override bool IsInEventLoop(XThread t) => this.thread == t;
+        public override bool IsInEventLoop(Thread t) => this.thread == t;
 
         void WakeUp(bool inEventLoop)
         {
diff --git a/src/DotNetty.Transport/Channels/DefaultChannelPipeline.cs b/src/DotNetty.Transport/Channels/DefaultChannelPipeline.cs
@@ -16,7 +16,6 @@ namespace DotNetty.Transport.Channels
     using DotNetty.Common.Concurrency;
     using DotNetty.Common.Internal.Logging;
     using DotNetty.Common.Utilities;
-    using Thread = DotNetty.Common.Concurrency.XThread;
 
     public class DefaultChannelPipeline : IChannelPipeline
     {
diff --git a/src/DotNetty.Transport/Channels/Embedded/EmbeddedEventLoop.cs b/src/DotNetty.Transport/Channels/Embedded/EmbeddedEventLoop.cs
@@ -5,10 +5,10 @@ namespace DotNetty.Transport.Channels.Embedded
 {
     using System;
     using System.Collections.Generic;
+    using System.Threading;
     using System.Threading.Tasks;
     using DotNetty.Common;
     using DotNetty.Common.Concurrency;
-    using Thread = DotNetty.Common.Concurrency.XThread;
 
     sealed class EmbeddedEventLoop : AbstractScheduledEventExecutor, IEventLoop
     {
diff --git a/test/DotNetty.Common.Tests/ThreadLocalPoolTest.cs b/test/DotNetty.Common.Tests/ThreadLocalPoolTest.cs
@@ -23,14 +23,13 @@ public void ThreadCanBeCollectedEvenIfHandledObjectIsReferencedTest()
             ThreadLocalPool<HandledObject> pool = NewPool(1024);
             HandledObject reference = null;
             WeakReference<Thread> threadRef = null;
-            WeakReference<XThread> xThreadRef = null;
 
             var thread1 = new Thread(() =>
             {
                 //Don't know the reason, but thread2 will not be collected without wrapped with thread1
                 var thread2 = new Thread(() =>
                 {
-                    Volatile.Write(ref xThreadRef, new WeakReference<XThread>(XThread.CurrentThread));
+                    Volatile.Write(ref threadRef, new WeakReference<Thread>(Thread.CurrentThread));
                     HandledObject data = pool.Take();
                     // Store a reference to the HandledObject to ensure it is not collected when the run method finish.
                     Volatile.Write(ref reference, data);
@@ -39,7 +38,6 @@ public void ThreadCanBeCollectedEvenIfHandledObjectIsReferencedTest()
                 thread2.Start();
                 thread2.Join();
                 Assert.True(Volatile.Read(ref threadRef)?.TryGetTarget(out _));
-                Assert.True(Volatile.Read(ref xThreadRef)?.TryGetTarget(out _));
 
                 GC.KeepAlive(thread2);
                 // Null out so it can be collected.
@@ -53,12 +51,11 @@ public void ThreadCanBeCollectedEvenIfHandledObjectIsReferencedTest()
                 GC.Collect(GC.MaxGeneration, GCCollectionMode.Forced, true);
                 GC.WaitForPendingFinalizers();
 
-                if (Volatile.Read(ref threadRef)?.TryGetTarget(out _) == true || Volatile.Read(ref xThreadRef)?.TryGetTarget(out _) == true)
+                if (Volatile.Read(ref threadRef)?.TryGetTarget(out _) == true || Volatile.Read(ref threadRef)?.TryGetTarget(out _) == true)
                     Thread.Sleep(100);
             }
 
             Assert.False(Volatile.Read(ref threadRef)?.TryGetTarget(out _));
-            Assert.False(Volatile.Read(ref xThreadRef)?.TryGetTarget(out _));
 
             // Now call recycle after the Thread was collected to ensure this still works...
             reference.Release();

Original file line number	Diff line number	Diff line change
`@@ -3,8 +3,8 @@`
`3`	`3`
`4`	`4`	`namespace DotNetty.Common.Concurrency`
`5`	`5`	`{`
`6`		`- using Thread = DotNetty.Common.Concurrency.XThread;`
`7`		`-`
	`6`	`+ using System.Threading;`
	`7`	`+`
`8`	`8`	`public interface IEventExecutor : IEventExecutorGroup`
`9`	`9`	`{`
`10`	`10`	`/// <summary>`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,6 @@ namespace DotNetty.Common`
`10`	`10`	`using DotNetty.Common.Concurrency;`
`11`	`11`	`using DotNetty.Common.Internal;`
`12`	`12`	`using DotNetty.Common.Internal.Logging;`
`13`		`- using Thread = DotNetty.Common.Concurrency.XThread;`
`14`	`13`
`15`	`14`	`public static class ThreadDeathWatcher`
`16`	`15`	`{`
Original file line number	Diff line number	Diff line change
`@@ -27,7 +27,7 @@ public sealed class HashedWheelTimer : ITimer`
`27`	`27`	`const int InstanceCountLimit = 64;`
`28`	`28`
`29`	`29`	`readonly Worker worker;`
`30`		`- readonly XThread workerThread;`
	`30`	`+ readonly Thread workerThread;`
`31`	`31`	`readonly CancellationTokenSource cancellationTokenSource = new CancellationTokenSource();`
`32`	`32`
`33`	`33`	`const int WorkerStateInit = 0;`
`@@ -98,7 +98,7 @@ public HashedWheelTimer(`
`98`	`98`	`tickInterval,`
`99`	`99`	`long.MaxValue / this.wheel.Length));`
`100`	`100`	`}`
`101`		`- this.workerThread = new XThread(st => this.worker.Run());`
	`101`	`+ this.workerThread = new Thread(st => this.worker.Run());`
`102`	`102`
`103`	`103`	`this.maxPendingTimeouts = maxPendingTimeouts;`
`104`	`104`
`@@ -187,7 +187,7 @@ public async Task<ISet<ITimeout>> StopAsync()`
`187`	`187`	`{`
`188`	`188`	`GC.SuppressFinalize(this);`
`189`	`189`
`190`		`- if (XThread.CurrentThread == this.workerThread)`
	`190`	`+ if (Thread.CurrentThread == this.workerThread)`
`191`	`191`	`{`
`192`	`192`	`throw new InvalidOperationException($"{nameof(HashedWheelTimer)}.stop() cannot be called from timer task.");`
`193`	`193`	`}`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,6 @@ namespace DotNetty.Common.Utilities`
`6`	`6`	`using System;`
`7`	`7`	`using System.Threading;`
`8`	`8`	`using DotNetty.Common.Internal.Logging;`
`9`		`- using Thread = DotNetty.Common.Concurrency.XThread;`
`10`	`9`
`11`	`10`	`public static class ReferenceCountUtil`
`12`	`11`	`{`
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,6 @@ namespace DotNetty.Common.Utilities`
`6`	`6`	`using System;`
`7`	`7`	`using System.Diagnostics.Contracts;`
`8`	`8`	`using System.Threading;`
`9`		`- using Thread = DotNetty.Common.Concurrency.XThread;`
`10`	`9`
`11`	`10`	`public static class ThreadExtensions`
`12`	`11`	`{`