netcore/System.Private.CoreLib/shared/System/Threading/Thread.cs

   1 // Licensed to the .NET Foundation under one or more agreements.
   2 // The .NET Foundation licenses this file to you under the MIT license.
   3 // See the LICENSE file in the project root for more information.
   4
   5 using System.Collections.Generic;
   6 using System.Diagnostics;
   7 using System.Diagnostics.CodeAnalysis;
   8 using System.Globalization;
   9 using System.Runtime.ConstrainedExecution;
  10 using System.Security.Principal;
  11
  12 namespace System.Threading
  13 {
  14     public sealed partial class Thread : CriticalFinalizerObject
  15     {
  16         private static AsyncLocal<IPrincipal?>? s_asyncLocalPrincipal;
  17
  18         [ThreadStatic]
  19         private static Thread? t_currentThread;
  20
  21         public Thread(ThreadStart start)
  22             : this()
  23         {
  24             if (start == null)
  25             {
  26                 throw new ArgumentNullException(nameof(start));
  27             }
  28
  29             Create(start);
  30         }
  31
  32         public Thread(ThreadStart start, int maxStackSize)
  33             : this()
  34         {
  35             if (start == null)
  36             {
  37                 throw new ArgumentNullException(nameof(start));
  38             }
  39             if (maxStackSize < 0)
  40             {
  41                 throw new ArgumentOutOfRangeException(nameof(maxStackSize), SR.ArgumentOutOfRange_NeedNonNegNum);
  42             }
  43
  44             Create(start, maxStackSize);
  45         }
  46
  47         public Thread(ParameterizedThreadStart start)
  48             : this()
  49         {
  50             if (start == null)
  51             {
  52                 throw new ArgumentNullException(nameof(start));
  53             }
  54
  55             Create(start);
  56         }
  57
  58         public Thread(ParameterizedThreadStart start, int maxStackSize)
  59             : this()
  60         {
  61             if (start == null)
  62             {
  63                 throw new ArgumentNullException(nameof(start));
  64             }
  65             if (maxStackSize < 0)
  66             {
  67                 throw new ArgumentOutOfRangeException(nameof(maxStackSize), SR.ArgumentOutOfRange_NeedNonNegNum);
  68             }
  69
  70             Create(start, maxStackSize);
  71         }
  72
  73         private void RequireCurrentThread()
  74         {
  75             if (this != CurrentThread)
  76             {
  77                 throw new InvalidOperationException(SR.Thread_Operation_RequiresCurrentThread);
  78             }
  79         }
  80
  81         private void SetCultureOnUnstartedThread(CultureInfo value, bool uiCulture)
  82         {
  83             if (value == null)
  84             {
  85                 throw new ArgumentNullException(nameof(value));
  86             }
  87             if ((ThreadState & ThreadState.Unstarted) == 0)
  88             {
  89                 throw new InvalidOperationException(SR.Thread_Operation_RequiresCurrentThread);
  90             }
  91             SetCultureOnUnstartedThreadNoCheck(value, uiCulture);
  92         }
  93
  94         partial void ThreadNameChanged(string? value);
  95
  96         public CultureInfo CurrentCulture
  97         {
  98             get
  99             {
 100                 RequireCurrentThread();
 101                 return CultureInfo.CurrentCulture;
 102             }
 103             set
 104             {
 105                 if (this != CurrentThread)
 106                 {
 107                     SetCultureOnUnstartedThread(value, uiCulture: false);
 108                     return;
 109                 }
 110                 CultureInfo.CurrentCulture = value;
 111             }
 112         }
 113
 114         public CultureInfo CurrentUICulture
 115         {
 116             get
 117             {
 118                 RequireCurrentThread();
 119                 return CultureInfo.CurrentUICulture;
 120             }
 121             set
 122             {
 123                 if (this != CurrentThread)
 124                 {
 125                     SetCultureOnUnstartedThread(value, uiCulture: true);
 126                     return;
 127                 }
 128                 CultureInfo.CurrentUICulture = value;
 129             }
 130         }
 131
 132         public static IPrincipal? CurrentPrincipal
 133         {
 134             get
 135             {
 136                 if (s_asyncLocalPrincipal is null)
 137                 {
 138                     CurrentPrincipal = AppDomain.CurrentDomain.GetThreadPrincipal();
 139                 }
 140                 return s_asyncLocalPrincipal?.Value;
 141             }
 142             set
 143             {
 144                 if (s_asyncLocalPrincipal is null)
 145                 {
 146                     if (value is null)
 147                     {
 148                         return;
 149                     }
 150                     Interlocked.CompareExchange(ref s_asyncLocalPrincipal, new AsyncLocal<IPrincipal?>(), null);
 151                 }
 152                 s_asyncLocalPrincipal.Value = value;
 153             }
 154         }
 155
 156         public static Thread CurrentThread => t_currentThread ?? InitializeCurrentThread();
 157
 158         public ExecutionContext? ExecutionContext => ExecutionContext.Capture();
 159
 160         public string? Name
 161         {
 162             get => _name;
 163             set
 164             {
 165                 lock (this)
 166                 {
 167                     if (_name != null)
 168                     {
 169                         throw new InvalidOperationException(SR.InvalidOperation_WriteOnce);
 170                     }
 171
 172                     _name = value;
 173
 174                     ThreadNameChanged(value);
 175                 }
 176             }
 177         }
 178
 179         public void Abort()
 180         {
 181             throw new PlatformNotSupportedException(SR.PlatformNotSupported_ThreadAbort);
 182         }
 183
 184         public void Abort(object? stateInfo)
 185         {
 186             throw new PlatformNotSupportedException(SR.PlatformNotSupported_ThreadAbort);
 187         }
 188
 189         public static void ResetAbort()
 190         {
 191             throw new PlatformNotSupportedException(SR.PlatformNotSupported_ThreadAbort);
 192         }
 193
 194         [ObsoleteAttribute("Thread.Suspend has been deprecated.  Please use other classes in System.Threading, such as Monitor, Mutex, Event, and Semaphore, to synchronize Threads or protect resources.  https://go.microsoft.com/fwlink/?linkid=14202", false)]
 195         public void Suspend()
 196         {
 197             throw new PlatformNotSupportedException(SR.PlatformNotSupported_ThreadSuspend);
 198         }
 199
 200         [ObsoleteAttribute("Thread.Resume has been deprecated.  Please use other classes in System.Threading, such as Monitor, Mutex, Event, and Semaphore, to synchronize Threads or protect resources.  https://go.microsoft.com/fwlink/?linkid=14202", false)]
 201         public void Resume()
 202         {
 203             throw new PlatformNotSupportedException(SR.PlatformNotSupported_ThreadSuspend);
 204         }
 205
 206         // Currently, no special handling is done for critical regions, and no special handling is necessary to ensure thread
 207         // affinity. If that changes, the relevant functions would instead need to delegate to RuntimeThread.
 208         public static void BeginCriticalRegion() { }
 209         public static void EndCriticalRegion() { }
 210         public static void BeginThreadAffinity() { }
 211         public static void EndThreadAffinity() { }
 212
 213         public static LocalDataStoreSlot AllocateDataSlot() => LocalDataStore.AllocateSlot();
 214         public static LocalDataStoreSlot AllocateNamedDataSlot(string name) => LocalDataStore.AllocateNamedSlot(name);
 215         public static LocalDataStoreSlot GetNamedDataSlot(string name) => LocalDataStore.GetNamedSlot(name);
 216         public static void FreeNamedDataSlot(string name) => LocalDataStore.FreeNamedSlot(name);
 217         public static object? GetData(LocalDataStoreSlot slot) => LocalDataStore.GetData(slot);
 218         public static void SetData(LocalDataStoreSlot slot, object? data) => LocalDataStore.SetData(slot, data);
 219
 220         [Obsolete("The ApartmentState property has been deprecated.  Use GetApartmentState, SetApartmentState or TrySetApartmentState instead.", false)]
 221         public ApartmentState ApartmentState
 222         {
 223             get
 224             {
 225                 return GetApartmentState();
 226             }
 227             set
 228             {
 229                 TrySetApartmentState(value);
 230             }
 231         }
 232
 233         public void SetApartmentState(ApartmentState state)
 234         {
 235             if (!TrySetApartmentState(state))
 236             {
 237                 throw GetApartmentStateChangeFailedException();
 238             }
 239         }
 240
 241         public bool TrySetApartmentState(ApartmentState state)
 242         {
 243             switch (state)
 244             {
 245                 case ApartmentState.STA:
 246                 case ApartmentState.MTA:
 247                 case ApartmentState.Unknown:
 248                     break;
 249
 250                 default:
 251                     throw new ArgumentOutOfRangeException(SR.ArgumentOutOfRange_Enum, nameof(state));
 252             }
 253
 254             return TrySetApartmentStateUnchecked(state);
 255         }
 256
 257         [Obsolete("Thread.GetCompressedStack is no longer supported. Please use the System.Threading.CompressedStack class")]
 258         public CompressedStack GetCompressedStack()
 259         {
 260             throw new InvalidOperationException(SR.Thread_GetSetCompressedStack_NotSupported);
 261         }
 262
 263         [Obsolete("Thread.SetCompressedStack is no longer supported. Please use the System.Threading.CompressedStack class")]
 264         public void SetCompressedStack(CompressedStack stack)
 265         {
 266             throw new InvalidOperationException(SR.Thread_GetSetCompressedStack_NotSupported);
 267         }
 268
 269         public static AppDomain GetDomain() => AppDomain.CurrentDomain;
 270         public static int GetDomainID() => 1;
 271         public override int GetHashCode() => ManagedThreadId;
 272         public void Join() => Join(-1);
 273         public bool Join(TimeSpan timeout) => Join(WaitHandle.ToTimeoutMilliseconds(timeout));
 274         public static void MemoryBarrier() => Interlocked.MemoryBarrier();
 275         public static void Sleep(TimeSpan timeout) => Sleep(WaitHandle.ToTimeoutMilliseconds(timeout));
 276
 277         public static byte VolatileRead(ref byte address) => Volatile.Read(ref address);
 278         public static double VolatileRead(ref double address) => Volatile.Read(ref address);
 279         public static short VolatileRead(ref short address) => Volatile.Read(ref address);
 280         public static int VolatileRead(ref int address) => Volatile.Read(ref address);
 281         public static long VolatileRead(ref long address) => Volatile.Read(ref address);
 282         public static IntPtr VolatileRead(ref IntPtr address) => Volatile.Read(ref address);
 283         [return: NotNullIfNotNull("address")]
 284         public static object? VolatileRead(ref object? address) => Volatile.Read(ref address);
 285         [CLSCompliant(false)]
 286         public static sbyte VolatileRead(ref sbyte address) => Volatile.Read(ref address);
 287         public static float VolatileRead(ref float address) => Volatile.Read(ref address);
 288         [CLSCompliant(false)]
 289         public static ushort VolatileRead(ref ushort address) => Volatile.Read(ref address);
 290         [CLSCompliant(false)]
 291         public static uint VolatileRead(ref uint address) => Volatile.Read(ref address);
 292         [CLSCompliant(false)]
 293         public static ulong VolatileRead(ref ulong address) => Volatile.Read(ref address);
 294         [CLSCompliant(false)]
 295         public static UIntPtr VolatileRead(ref UIntPtr address) => Volatile.Read(ref address);
 296         public static void VolatileWrite(ref byte address, byte value) => Volatile.Write(ref address, value);
 297         public static void VolatileWrite(ref double address, double value) => Volatile.Write(ref address, value);
 298         public static void VolatileWrite(ref short address, short value) => Volatile.Write(ref address, value);
 299         public static void VolatileWrite(ref int address, int value) => Volatile.Write(ref address, value);
 300         public static void VolatileWrite(ref long address, long value) => Volatile.Write(ref address, value);
 301         public static void VolatileWrite(ref IntPtr address, IntPtr value) => Volatile.Write(ref address, value);
 302         public static void VolatileWrite([NotNullIfNotNull("value")] ref object? address, object? value) => Volatile.Write(ref address, value);
 303         [CLSCompliant(false)]
 304         public static void VolatileWrite(ref sbyte address, sbyte value) => Volatile.Write(ref address, value);
 305         public static void VolatileWrite(ref float address, float value) => Volatile.Write(ref address, value);
 306         [CLSCompliant(false)]
 307         public static void VolatileWrite(ref ushort address, ushort value) => Volatile.Write(ref address, value);
 308         [CLSCompliant(false)]
 309         public static void VolatileWrite(ref uint address, uint value) => Volatile.Write(ref address, value);
 310         [CLSCompliant(false)]
 311         public static void VolatileWrite(ref ulong address, ulong value) => Volatile.Write(ref address, value);
 312         [CLSCompliant(false)]
 313         public static void VolatileWrite(ref UIntPtr address, UIntPtr value) => Volatile.Write(ref address, value);
 314
 315         /// <summary>
 316         /// Manages functionality required to support members of <see cref="Thread"/> dealing with thread-local data
 317         /// </summary>
 318         private static class LocalDataStore
 319         {
 320             private static Dictionary<string, LocalDataStoreSlot>? s_nameToSlotMap;
 321
 322             public static LocalDataStoreSlot AllocateSlot()
 323             {
 324                 return new LocalDataStoreSlot(new ThreadLocal<object?>());
 325             }
 326
 327             private static Dictionary<string, LocalDataStoreSlot> EnsureNameToSlotMap()
 328             {
 329                 Dictionary<string, LocalDataStoreSlot>? nameToSlotMap = s_nameToSlotMap;
 330                 if (nameToSlotMap != null)
 331                 {
 332                     return nameToSlotMap;
 333                 }
 334
 335                 nameToSlotMap = new Dictionary<string, LocalDataStoreSlot>();
 336                 return Interlocked.CompareExchange(ref s_nameToSlotMap, nameToSlotMap, null) ?? nameToSlotMap;
 337             }
 338
 339             public static LocalDataStoreSlot AllocateNamedSlot(string name)
 340             {
 341                 LocalDataStoreSlot slot = AllocateSlot();
 342                 Dictionary<string, LocalDataStoreSlot> nameToSlotMap = EnsureNameToSlotMap();
 343                 lock (nameToSlotMap)
 344                 {
 345                     nameToSlotMap.Add(name, slot);
 346                 }
 347                 return slot;
 348             }
 349
 350             public static LocalDataStoreSlot GetNamedSlot(string name)
 351             {
 352                 Dictionary<string, LocalDataStoreSlot> nameToSlotMap = EnsureNameToSlotMap();
 353                 lock (nameToSlotMap)
 354                 {
 355                     LocalDataStoreSlot? slot;
 356                     if (!nameToSlotMap.TryGetValue(name, out slot))
 357                     {
 358                         slot = AllocateSlot();
 359                         nameToSlotMap[name] = slot;
 360                     }
 361                     return slot;
 362                 }
 363             }
 364
 365             public static void FreeNamedSlot(string name)
 366             {
 367                 Dictionary<string, LocalDataStoreSlot> nameToSlotMap = EnsureNameToSlotMap();
 368                 lock (nameToSlotMap)
 369                 {
 370                     nameToSlotMap.Remove(name);
 371                 }
 372             }
 373
 374             private static ThreadLocal<object?> GetThreadLocal(LocalDataStoreSlot slot)
 375             {
 376                 if (slot == null)
 377                 {
 378                     throw new ArgumentNullException(nameof(slot));
 379                 }
 380
 381                 Debug.Assert(slot.Data != null);
 382                 return slot.Data;
 383             }
 384
 385             public static object? GetData(LocalDataStoreSlot slot)
 386             {
 387                 return GetThreadLocal(slot).Value;
 388             }
 389
 390             public static void SetData(LocalDataStoreSlot slot, object? value)
 391             {
 392                 GetThreadLocal(slot).Value = value;
 393             }
 394         }
 395     }
 396 }