netcore/System.Private.CoreLib/src/System/Threading/Thread.Mono.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.Globalization;
   6 using System.Runtime.CompilerServices;
   7 using System.Runtime.InteropServices;
   8
   9 namespace System.Threading
  10 {
  11         //
  12         // Under netcore, there is only one thread object per thread
  13         //
  14         [StructLayout (LayoutKind.Sequential)]
  15         partial class Thread
  16         {
  17 #pragma warning disable 169, 414, 649
  18                 #region Sync with metadata/object-internals.h and InternalThread in mcs/class/corlib/System.Threading/Thread.cs
  19                 int lock_thread_id;
  20                 // stores a thread handle
  21                 IntPtr handle;
  22                 IntPtr native_handle; // used only on Win32
  23                 /* accessed only from unmanaged code */
  24                 private IntPtr name;
  25                 private int name_free; // bool
  26                 private int name_length;
  27                 private ThreadState state;
  28                 private object abort_exc;
  29                 private int abort_state_handle;
  30                 /* thread_id is only accessed from unmanaged code */
  31                 internal Int64 thread_id;
  32                 private IntPtr debugger_thread; // FIXME switch to bool as soon as CI testing with corlib version bump works
  33                 private UIntPtr static_data; /* GC-tracked */
  34                 private IntPtr runtime_thread_info;
  35                 /* current System.Runtime.Remoting.Contexts.Context instance
  36                    keep as an object to avoid triggering its class constructor when not needed */
  37                 private object current_appcontext;
  38                 private object root_domain_thread;
  39                 internal byte[] _serialized_principal;
  40                 internal int _serialized_principal_version;
  41                 private IntPtr appdomain_refs;
  42                 private int interruption_requested;
  43                 private IntPtr longlived;
  44                 internal bool threadpool_thread;
  45                 private bool thread_interrupt_requested;
  46                 /* These are used from managed code */
  47                 internal int stack_size;
  48                 internal byte apartment_state;
  49                 internal volatile int critical_region_level;
  50                 internal int managed_id;
  51                 private int small_id;
  52                 private IntPtr manage_callback;
  53                 private IntPtr flags;
  54                 private IntPtr thread_pinning_ref;
  55                 private IntPtr abort_protected_block_count;
  56                 private int priority;
  57                 private IntPtr owned_mutex;
  58                 private IntPtr suspended_event;
  59                 private int self_suspended;
  60                 private IntPtr thread_state;
  61
  62                 private Thread self;
  63                 private object pending_exception;
  64                 private object start_obj;
  65
  66                 /* This is used only to check that we are in sync between the representation
  67                  * of MonoInternalThread in native and InternalThread in managed
  68                  *
  69                  * DO NOT RENAME! DO NOT ADD FIELDS AFTER! */
  70                 private IntPtr last;
  71                 #endregion
  72 #pragma warning restore 169, 414, 649
  73
  74                 string _name;
  75                 Delegate m_start;
  76                 object m_start_arg;
  77                 CultureInfo culture, ui_culture;
  78                 internal ExecutionContext _executionContext;
  79                 internal SynchronizationContext _synchronizationContext;
  80
  81                 Thread ()
  82                 {
  83                         InitInternal (this);
  84                 }
  85
  86                 ~Thread ()
  87                 {
  88                         FreeInternal ();
  89                 }
  90
  91                 internal static ulong CurrentOSThreadId {
  92                         get {
  93                                 return GetCurrentOSThreadId ();
  94                         }
  95                 }
  96
  97                 public bool IsAlive {
  98                         get {
  99                                 var state = GetState (this);
 100                                 return (state & (ThreadState.Unstarted | ThreadState.Stopped | ThreadState.Aborted)) == 0;
 101                         }
 102                 }
 103
 104                 public bool IsBackground {
 105                         get {
 106                                 var state = ValidateThreadState ();
 107                                 return (state & ThreadState.Background) != 0;
 108                         }
 109                         set {
 110                                 ValidateThreadState ();
 111                                 if (value) {
 112                                         SetState (this, ThreadState.Background);
 113                                 } else {
 114                                         ClrState (this, ThreadState.Background);
 115                                 }
 116                         }
 117                 }
 118
 119                 public bool IsThreadPoolThread {
 120                         get {
 121                                 ValidateThreadState ();
 122                                 return threadpool_thread;
 123                         }
 124                         internal set {
 125                                 threadpool_thread = value;
 126                         }
 127                 }
 128
 129                 public int ManagedThreadId => managed_id;
 130
 131                 internal static int OptimalMaxSpinWaitsPerSpinIteration {
 132                         get {
 133                                 // Default from coreclr (src/utilcode/yieldprocessornormalized.cpp)
 134                                 return 7;
 135                         }
 136                 }
 137
 138                 public ThreadPriority Priority {
 139                         get {
 140                                 ValidateThreadState ();
 141                                 return (ThreadPriority) priority;
 142                          }
 143                         set {
 144                                 // TODO: arguments check
 145                                 SetPriority (this, (int) value);
 146                         }
 147                 }
 148
 149                 public ThreadState ThreadState => GetState (this);
 150
 151                 void Create (ThreadStart start) => SetStartHelper ((Delegate) start, 0); // 0 will setup Thread with default stackSize
 152
 153                 void Create (ThreadStart start, int maxStackSize) => SetStartHelper ((Delegate) start, maxStackSize);
 154
 155                 void Create (ParameterizedThreadStart start) => SetStartHelper ((Delegate) start, 0);
 156
 157                 void Create (ParameterizedThreadStart start, int maxStackSize) => SetStartHelper ((Delegate) start, maxStackSize);
 158
 159                 public ApartmentState GetApartmentState () => ApartmentState.Unknown;
 160
 161                 public void DisableComObjectEagerCleanup ()
 162                 {
 163                         // no-op
 164                 }
 165
 166                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 167                 extern static int GetCurrentProcessorNumber ();
 168
 169                 public static int GetCurrentProcessorId ()
 170                 {
 171                         int id = GetCurrentProcessorNumber ();
 172
 173                         if (id < 0)
 174                                 id = Environment.CurrentManagedThreadId;
 175
 176                         return id;
 177                 }
 178
 179                 public void Interrupt ()
 180                 {
 181                         InterruptInternal (this);
 182                 }
 183
 184                 public bool Join (int millisecondsTimeout)
 185                 {
 186                         if (millisecondsTimeout < Timeout.Infinite)
 187                                 throw new ArgumentOutOfRangeException (nameof (millisecondsTimeout), millisecondsTimeout, SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
 188                         return JoinInternal (this, millisecondsTimeout);
 189                 }
 190
 191                 internal void ResetThreadPoolThread ()
 192                 {
 193                         if (_name != null)
 194                                 Name = null;
 195
 196                         if ((state & ThreadState.Background) == 0)
 197                                 IsBackground = true;
 198
 199                         if ((ThreadPriority) priority != ThreadPriority.Normal)
 200                                 Priority = ThreadPriority.Normal;
 201                 }
 202
 203                 void SetCultureOnUnstartedThreadNoCheck (CultureInfo value, bool uiCulture)
 204                 {
 205                         if (uiCulture)
 206                                 ui_culture = value;
 207                         else
 208                                 culture = value;
 209                 }
 210
 211                 void SetStartHelper (Delegate start, int maxStackSize)
 212                 {
 213                         m_start = start;
 214                         stack_size = maxStackSize;
 215                 }
 216
 217                 public static void SpinWait (int iterations)
 218                 {
 219                         if (iterations < 0)
 220                                 return;
 221
 222                         while (iterations-- > 0)
 223                                 SpinWait_nop ();
 224                 }
 225
 226                 public static void Sleep (int millisecondsTimeout)
 227                 {
 228                         if (millisecondsTimeout < Timeout.Infinite)
 229                                 throw new ArgumentOutOfRangeException (nameof (millisecondsTimeout), millisecondsTimeout, SR.ArgumentOutOfRange_NeedNonNegOrNegative1);
 230
 231                         SleepInternal (millisecondsTimeout, true);
 232                 }
 233
 234                 internal static void UninterruptibleSleep0 () => SleepInternal (0, false);
 235
 236                 public void Start ()
 237                 {
 238                         StartInternal (this);
 239                 }
 240
 241                 public void Start (object parameter)
 242                 {
 243                         if (m_start is ThreadStart)
 244                                 throw new InvalidOperationException (SR.InvalidOperation_ThreadWrongThreadStart);
 245
 246                         m_start_arg = parameter;
 247                         StartInternal (this);
 248                 }
 249
 250                 // Called from the runtime
 251                 internal void StartCallback ()
 252                 {
 253                         if (culture != null)
 254                                 CurrentCulture = culture;
 255                         if (ui_culture != null)
 256                                 CurrentUICulture = ui_culture;
 257                         if (m_start is ThreadStart del) {
 258                                 m_start = null;
 259                                 del ();
 260                         } else {
 261                                 var pdel = (ParameterizedThreadStart) m_start;
 262                                 var arg = m_start_arg;
 263                                 m_start = null;
 264                                 m_start_arg = null;
 265                                 pdel (arg);
 266                         }
 267                 }
 268
 269                 partial void ThreadNameChanged (string value)
 270                 {
 271                         // TODO: Should only raise the events
 272                         SetName (this, value);
 273                 }
 274
 275                 public static bool Yield ()
 276                 {
 277                         return YieldInternal ();
 278                 }
 279
 280                 bool TrySetApartmentStateUnchecked (ApartmentState state) => state == ApartmentState.Unknown;
 281
 282                 ThreadState ValidateThreadState ()
 283                 {
 284                         var state = GetState (this);
 285                         if ((state & ThreadState.Stopped) != 0)
 286                                 throw new ThreadStateException ("Thread is dead; state can not be accessed.");
 287                         return state;
 288                 }
 289
 290                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 291                 private extern static ulong GetCurrentOSThreadId ();
 292
 293                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 294                 extern static void InitInternal (Thread thread);
 295
 296                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 297                 private extern static void InitializeCurrentThread_icall (ref Thread thread);
 298
 299                 [MethodImpl (MethodImplOptions.NoInlining)]
 300                 static Thread InitializeCurrentThread () {
 301                         Thread thread = null;
 302                         InitializeCurrentThread_icall (ref thread);
 303                         return thread;
 304                 }
 305
 306                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 307                 extern void FreeInternal ();
 308
 309                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 310                 extern static ThreadState GetState (Thread thread);
 311
 312                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 313                 extern static void SetState (Thread thread, ThreadState set);
 314
 315                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 316                 extern static void ClrState (Thread thread, ThreadState clr);
 317
 318                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 319                 extern static string GetName (Thread thread);
 320
 321                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 322                 private static unsafe extern void SetName_icall (Thread thread, char *name, int nameLength);
 323
 324                 static unsafe void SetName (Thread thread, String name)
 325                 {
 326                         fixed (char* fixed_name = name)
 327                                 SetName_icall (thread, fixed_name, name?.Length ?? 0);
 328                 }
 329
 330                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 331                 extern static bool YieldInternal ();
 332
 333                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 334                 extern static void SleepInternal (int millisecondsTimeout, bool allowInterruption);
 335
 336                 [Intrinsic]
 337                 static void SpinWait_nop ()
 338                 {
 339                 }
 340
 341                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 342                 extern static Thread CreateInternal ();
 343
 344                 [MethodImplAttribute (MethodImplOptions.InternalCall)]
 345                 extern static void StartInternal (Thread runtime_thread);
 346
 347                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 348                 extern static bool JoinInternal (Thread thread, int millisecondsTimeout);
 349
 350                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 351                 extern static void InterruptInternal (Thread thread);
 352
 353                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
 354                 extern static void SetPriority (Thread thread, int priority);
 355         }
 356 }