Replace a couple Thread.CurrentThread.ManagedThreadIds (#43270)

* Replace a few Thread.CurrentThread.ManagedThreadIds * Update some library tests as well
dotnet · Oct 13, 2020 · 1d9b5e0 · 1d9b5e0
1 parent 6a59725
commit 1d9b5e0
Show file tree

Hide file tree

Showing 10 changed files with 20 additions and 25 deletions.
diff --git a/src/libraries/Microsoft.Win32.SystemEvents/tests/SystemEvents.InvokeOnEventsThread.cs b/src/libraries/Microsoft.Win32.SystemEvents/tests/SystemEvents.InvokeOnEventsThread.cs
@@ -29,7 +29,7 @@ public void InvokeOnEventsThreadRunsOnSameThreadAsOtherEvents()
             var invoked = new AutoResetEvent(false);
             EventHandler handler = (sender, args) =>
             {
-                expectedThreadId = Thread.CurrentThread.ManagedThreadId;
+                expectedThreadId = Environment.CurrentManagedThreadId;
             };
 
             try
@@ -41,7 +41,7 @@ public void InvokeOnEventsThreadRunsOnSameThreadAsOtherEvents()
 
                 SystemEvents.InvokeOnEventsThread(new Action(() =>
                 {
-                    actualThreadId = Thread.CurrentThread.ManagedThreadId;
+                    actualThreadId = Environment.CurrentManagedThreadId;
                     invoked.Set();
                 }));
                 Assert.True(invoked.WaitOne(PostMessageWait));

diff --git a/src/libraries/System.Diagnostics.EventLog/src/System/Diagnostics/Reader/EventLogWatcher.cs b/src/libraries/System.Diagnostics.EventLog/src/System/Diagnostics/Reader/EventLogWatcher.cs
@@ -107,7 +107,7 @@ internal void StopSubscribing()
 
                 _registeredWaitHandle.Unregister(_unregisterDoneHandle);
 
-                if (_callbackThreadId != Thread.CurrentThread.ManagedThreadId)
+                if (_callbackThreadId != Environment.CurrentManagedThreadId)
                 {
                     // Not calling Stop from within callback - wait for
                     // Any outstanding callbacks to complete.
@@ -211,7 +211,7 @@ internal void StartSubscribing()
 
         internal void SubscribedEventsAvailableCallback(object state, bool timedOut)
         {
-            _callbackThreadId = Thread.CurrentThread.ManagedThreadId;
+            _callbackThreadId = Environment.CurrentManagedThreadId;
             try
             {
                 RequestEvents();

diff --git a/src/libraries/System.Diagnostics.Tracing/tests/BasicEventSourceTest/TestEventCounter.cs b/src/libraries/System.Diagnostics.Tracing/tests/BasicEventSourceTest/TestEventCounter.cs
@@ -213,7 +213,7 @@ private void Test_Write_Metric(Listener listener)
                         ValidateSingleEventCounter(evts[1], "Error", 0, 0, 0, float.PositiveInfinity, float.NegativeInfinity);
 
                         // We shoudl always get the unconditional callback at the start and end of the trace.
-                        Assert.True(4 <= evts.Count, $"FAILURE EventCounter Multi-event: 4 <= {evts.Count} ticks: {num100msecTimerTicks} thread: {Thread.CurrentThread.ManagedThreadId}");
+                        Assert.True(4 <= evts.Count, $"FAILURE EventCounter Multi-event: 4 <= {evts.Count} ticks: {num100msecTimerTicks} thread: {Environment.CurrentManagedThreadId}");
                         // We expect the timer to have gone off at least twice, plus the explicit poll at the beginning and end.
                         // Each one fires two events (one for requests, one for errors). so that is (2 + 2)*2 = 8
                         // We expect about 7 timer requests, but we don't get picky about the exact count

diff --git a/src/libraries/System.IO.Pipelines/tests/SchedulerFacts.cs b/src/libraries/System.IO.Pipelines/tests/SchedulerFacts.cs
@@ -439,7 +439,7 @@ public async Task FlushCallbackRunsOnWriterScheduler()
 
                         pipe.Writer.Complete();
 
-                        Assert.Equal(Thread.CurrentThread.ManagedThreadId, scheduler.Thread.ManagedThreadId);
+                        Assert.Equal(Environment.CurrentManagedThreadId, scheduler.Thread.ManagedThreadId);
                     };
 
                     Task writing = ExecuteOnNonThreadPoolThread(doWrite);
@@ -470,7 +470,7 @@ public async Task ReadAsyncCallbackRunsOnReaderScheduler()
 
                         ReadResult result = await pipe.Reader.ReadAsync();
 
-                        Assert.Equal(Thread.CurrentThread.ManagedThreadId, scheduler.Thread.ManagedThreadId);
+                        Assert.Equal(Environment.CurrentManagedThreadId, scheduler.Thread.ManagedThreadId);
 
                         pipe.Reader.AdvanceTo(result.Buffer.End, result.Buffer.End);
 

diff --git a/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientTest.cs b/src/libraries/System.Net.Http/tests/FunctionalTests/HttpClientTest.cs
@@ -848,16 +848,16 @@ public void Dispose_UsePatchAfterDispose_Throws()
         [InlineData(HttpCompletionOption.ResponseHeadersRead)]
         public void Send_SingleThread_Succeeds(HttpCompletionOption completionOption)
         {
-            int currentThreadId = Thread.CurrentThread.ManagedThreadId;
+            int currentThreadId = Environment.CurrentManagedThreadId;
 
             var client = new HttpClient(new CustomResponseHandler((r, c) => 
             {
-                Assert.Equal(currentThreadId, Thread.CurrentThread.ManagedThreadId);
+                Assert.Equal(currentThreadId, Environment.CurrentManagedThreadId);
                 return Task.FromResult(new HttpResponseMessage()
                     {
                         Content = new CustomContent(stream =>
                         {
-                            Assert.Equal(currentThreadId, Thread.CurrentThread.ManagedThreadId);
+                            Assert.Equal(currentThreadId, Environment.CurrentManagedThreadId);
                         })
                     });
             }));
@@ -867,12 +867,12 @@ public void Send_SingleThread_Succeeds(HttpCompletionOption completionOption)
                     {
                         Content = new CustomContent(stream =>
                         {
-                            Assert.Equal(currentThreadId, Thread.CurrentThread.ManagedThreadId);
+                            Assert.Equal(currentThreadId, Environment.CurrentManagedThreadId);
                         })
                     }, completionOption);
 
                 Stream contentStream = response.Content.ReadAsStream();
-                Assert.Equal(currentThreadId, Thread.CurrentThread.ManagedThreadId);
+                Assert.Equal(currentThreadId, Environment.CurrentManagedThreadId);
             }
         }
 
@@ -894,20 +894,20 @@ await LoopbackServer.CreateClientAndServerAsync(
                         // To prevent deadlock
                         await Task.Yield();
 
-                        int currentThreadId = Thread.CurrentThread.ManagedThreadId;
+                        int currentThreadId = Environment.CurrentManagedThreadId;
 
                         using HttpClient httpClient = CreateHttpClient();
 
                         HttpResponseMessage response = httpClient.Send(new HttpRequestMessage(HttpMethod.Get, uri) {
                             Content = new CustomContent(stream =>
                             {
-                                Assert.Equal(currentThreadId, Thread.CurrentThread.ManagedThreadId);
+                                Assert.Equal(currentThreadId, Environment.CurrentManagedThreadId);
                                 stream.Write(Encoding.UTF8.GetBytes(content));
                             })
                         }, completionOption);
 
                         Stream contentStream = response.Content.ReadAsStream();
-                        Assert.Equal(currentThreadId, Thread.CurrentThread.ManagedThreadId);                        
+                        Assert.Equal(currentThreadId, Environment.CurrentManagedThreadId);                        
                         using (StreamReader sr = new StreamReader(contentStream))
                         {
                             Assert.Equal(content, sr.ReadToEnd());

diff --git a/src/libraries/System.Private.CoreLib/src/System/Threading/ThreadPool.cs b/src/libraries/System.Private.CoreLib/src/System/Threading/ThreadPool.cs
@@ -711,7 +711,7 @@ internal sealed class ThreadPoolWorkQueueThreadLocals
         public readonly ThreadPoolWorkQueue workQueue;
         public readonly ThreadPoolWorkQueue.WorkStealingQueue workStealingQueue;
         public readonly Thread currentThread;
-        public FastRandom random = new FastRandom(Thread.CurrentThread.ManagedThreadId); // mutable struct, do not copy or make readonly
+        public FastRandom random = new FastRandom(Environment.CurrentManagedThreadId); // mutable struct, do not copy or make readonly
 
         public ThreadPoolWorkQueueThreadLocals(ThreadPoolWorkQueue tpq)
         {

diff --git a/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/Dbg.cs b/src/libraries/System.Runtime.Caching/src/System/Runtime/Caching/Dbg.cs
@@ -36,7 +36,7 @@ internal static void Trace(string tagName, string message, Exception e = null)
 
             string output = string.Format(CultureInfo.InvariantCulture,
                  "[{0}] {1} {2}{3}{4}",
-                 Thread.CurrentThread.ManagedThreadId,
+                 Environment.CurrentManagedThreadId,
                  tagName,
                  message,
                  Environment.NewLine,

diff --git a/src/libraries/System.Threading.Tasks.Parallel/tests/ParallelStateTest.cs b/src/libraries/System.Threading.Tasks.Parallel/tests/ParallelStateTest.cs
@@ -710,7 +710,7 @@ private List<long> ThreadLocalInit64()
         private void ThreadLocalFinally64(List<long> local)
         {
             //add this row to the global sequences
-            //sequences.Add(Thread.CurrentThread.ManagedThreadId, local);
+            //sequences.Add(Environment.CurrentManagedThreadId, local);
             long index = Interlocked.Increment(ref _threadCount) - 1;
             _sequences64[index] = local;
         }
@@ -733,7 +733,7 @@ private List<int> ThreadLocalInit()
         private void ThreadLocalFinally(List<int> local)
         {
             //add this row to the global sequences
-            //sequences.Add(Thread.CurrentThread.ManagedThreadId, local);
+            //sequences.Add(Environment.CurrentManagedThreadId, local);
             long index = Interlocked.Increment(ref _threadCount) - 1;
             _sequences[(int)index] = local;
         }

diff --git a/src/libraries/System.Threading.Tasks/tests/CancellationTokenTests.cs b/src/libraries/System.Threading.Tasks/tests/CancellationTokenTests.cs
@@ -1715,8 +1715,6 @@ public override void Send(SendOrPostCallback d, object state)
                 Task t = new Task(
                     (passedInState) =>
                     {
-                        //Debug.WriteLine(" threadCrossingSyncContext..running callback delegate on threadID = " + Thread.CurrentThread.ManagedThreadId);
-
                         try
                         {
                             d(passedInState);
@@ -1730,9 +1728,6 @@ public override void Send(SendOrPostCallback d, object state)
                 t.Start();
                 t.Wait();
 
-                //t.Start(state);
-                //t.Join();
-
                 if (marshalledException != null)
                     throw new AggregateException("DUMMY: ThreadCrossingSynchronizationContext.Send captured and propogated an exception",
                         marshalledException);

diff --git a/src/libraries/System.Threading.Thread/tests/ThreadTests.cs b/src/libraries/System.Threading.Thread/tests/ThreadTests.cs
@@ -606,7 +606,7 @@ public static void ManagedThreadIdTest()
             var t = ThreadTestHelpers.CreateGuardedThread(out waitForThread, e.CheckedWait);
             t.IsBackground = true;
             t.Start();
-            Assert.NotEqual(Thread.CurrentThread.ManagedThreadId, t.ManagedThreadId);
+            Assert.NotEqual(Environment.CurrentManagedThreadId, t.ManagedThreadId);
             e.Set();
             waitForThread();
         }