# System.Threading

``` diff
+namespace System.Threading {
+    public class AbandonedMutexException : Exception {
+        public AbandonedMutexException();
+        public AbandonedMutexException(int location, WaitHandle handle);
+        public AbandonedMutexException(string message);
+        public AbandonedMutexException(string message, Exception inner);
+        public AbandonedMutexException(string message, Exception inner, int location, WaitHandle handle);
+        public AbandonedMutexException(string message, int location, WaitHandle handle);
+        public Mutex Mutex { get; }
+        public int MutexIndex { get; }
+    }
+    public sealed class AsyncLocal<T> {
+        public AsyncLocal();
+        public AsyncLocal(Action<AsyncLocalValueChangedArgs<T>> valueChangedHandler);
+        public T Value { get; set; }
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct AsyncLocalValueChangedArgs<T> {
+        public T CurrentValue { get; }
+        public T PreviousValue { get; }
+        public bool ThreadContextChanged { get; }
+    }
+    public sealed class AutoResetEvent : EventWaitHandle {
+        public AutoResetEvent(bool initialState);
+    }
+    public class Barrier : IDisposable {
+        public Barrier(int participantCount);
+        public Barrier(int participantCount, Action<Barrier> postPhaseAction);
+        public long CurrentPhaseNumber { get; }
+        public int ParticipantCount { get; }
+        public int ParticipantsRemaining { get; }
+        public long AddParticipant();
+        public long AddParticipants(int participantCount);
+        public void Dispose();
+        protected virtual void Dispose(bool disposing);
+        public void RemoveParticipant();
+        public void RemoveParticipants(int participantCount);
+        public void SignalAndWait();
+        public bool SignalAndWait(int millisecondsTimeout);
+        public bool SignalAndWait(int millisecondsTimeout, CancellationToken cancellationToken);
+        public void SignalAndWait(CancellationToken cancellationToken);
+        public bool SignalAndWait(TimeSpan timeout);
+        public bool SignalAndWait(TimeSpan timeout, CancellationToken cancellationToken);
+    }
+    public class BarrierPostPhaseException : Exception {
+        public BarrierPostPhaseException();
+        public BarrierPostPhaseException(Exception innerException);
+        public BarrierPostPhaseException(string message);
+        public BarrierPostPhaseException(string message, Exception innerException);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct CancellationToken {
+        public CancellationToken(bool canceled);
+        public bool CanBeCanceled { get; }
+        public bool IsCancellationRequested { get; }
+        public static CancellationToken None { get; }
+        public WaitHandle WaitHandle { get; }
+        public override bool Equals(object other);
+        public bool Equals(CancellationToken other);
+        public override int GetHashCode();
+        public static bool operator ==(CancellationToken left, CancellationToken right);
+        public static bool operator !=(CancellationToken left, CancellationToken right);
+        public CancellationTokenRegistration Register(Action callback);
+        public CancellationTokenRegistration Register(Action callback, bool useSynchronizationContext);
+        public CancellationTokenRegistration Register(Action<object> callback, object state);
+        public CancellationTokenRegistration Register(Action<object> callback, object state, bool useSynchronizationContext);
+        public void ThrowIfCancellationRequested();
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct CancellationTokenRegistration : IDisposable, IEquatable<CancellationTokenRegistration> {
+        public void Dispose();
+        public override bool Equals(object obj);
+        public bool Equals(CancellationTokenRegistration other);
+        public override int GetHashCode();
+        public static bool operator ==(CancellationTokenRegistration left, CancellationTokenRegistration right);
+        public static bool operator !=(CancellationTokenRegistration left, CancellationTokenRegistration right);
+    }
+    public class CancellationTokenSource : IDisposable {
+        public CancellationTokenSource();
+        public CancellationTokenSource(int millisecondsDelay);
+        public CancellationTokenSource(TimeSpan delay);
+        public bool IsCancellationRequested { get; }
+        public CancellationToken Token { get; }
+        public void Cancel();
+        public void Cancel(bool throwOnFirstException);
+        public void CancelAfter(int millisecondsDelay);
+        public void CancelAfter(TimeSpan delay);
+        public static CancellationTokenSource CreateLinkedTokenSource(CancellationToken token1, CancellationToken token2);
+        public static CancellationTokenSource CreateLinkedTokenSource(params CancellationToken[] tokens);
+        public void Dispose();
+        protected virtual void Dispose(bool disposing);
+    }
+    public delegate void ContextCallback(object state);
+    public class CountdownEvent : IDisposable {
+        public CountdownEvent(int initialCount);
+        public int CurrentCount { get; }
+        public int InitialCount { get; }
+        public bool IsSet { get; }
+        public WaitHandle WaitHandle { get; }
+        public void AddCount();
+        public void AddCount(int signalCount);
+        public void Dispose();
+        protected virtual void Dispose(bool disposing);
+        public void Reset();
+        public void Reset(int count);
+        public bool Signal();
+        public bool Signal(int signalCount);
+        public bool TryAddCount();
+        public bool TryAddCount(int signalCount);
+        public void Wait();
+        public bool Wait(int millisecondsTimeout);
+        public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken);
+        public void Wait(CancellationToken cancellationToken);
+        public bool Wait(TimeSpan timeout);
+        public bool Wait(TimeSpan timeout, CancellationToken cancellationToken);
+    }
+    public enum EventResetMode {
+        AutoReset = 0,
+        ManualReset = 1,
+    }
+    public class EventWaitHandle : WaitHandle {
+        public EventWaitHandle(bool initialState, EventResetMode mode);
+        public EventWaitHandle(bool initialState, EventResetMode mode, string name);
+        public EventWaitHandle(bool initialState, EventResetMode mode, string name, out bool createdNew);
+        public static EventWaitHandle OpenExisting(string name);
+        public bool Reset();
+        public bool Set();
+        public static bool TryOpenExisting(string name, out EventWaitHandle result);
+    }
+    public sealed class ExecutionContext {
+        public static ExecutionContext Capture();
+        public void Dispose();
+        public static void Run(ExecutionContext executionContext, ContextCallback callback, object state);
+    }
+    public static class Interlocked {
+        public static int Add(ref int location1, int value);
+        public static long Add(ref long location1, long value);
+        public static double CompareExchange(ref double location1, double value, double comparand);
+        public static int CompareExchange(ref int location1, int value, int comparand);
+        public static long CompareExchange(ref long location1, long value, long comparand);
+        public static IntPtr CompareExchange(ref IntPtr location1, IntPtr value, IntPtr comparand);
+        public static object CompareExchange(ref object location1, object value, object comparand);
+        public static float CompareExchange(ref float location1, float value, float comparand);
+        public static T CompareExchange<T>(ref T location1, T value, T comparand) where T : class;
+        public static int Decrement(ref int location);
+        public static long Decrement(ref long location);
+        public static double Exchange(ref double location1, double value);
+        public static int Exchange(ref int location1, int value);
+        public static long Exchange(ref long location1, long value);
+        public static IntPtr Exchange(ref IntPtr location1, IntPtr value);
+        public static object Exchange(ref object location1, object value);
+        public static float Exchange(ref float location1, float value);
+        public static T Exchange<T>(ref T location1, T value) where T : class;
+        public static int Increment(ref int location);
+        public static long Increment(ref long location);
+        public static void MemoryBarrier();
+        public static long Read(ref long location);
+    }
+    public unsafe delegate void IOCompletionCallback(uint errorCode, uint numBytes, NativeOverlapped* pOVERLAP);
+    public static class LazyInitializer {
+        public static T EnsureInitialized<T>(ref T target) where T : class;
+        public static T EnsureInitialized<T>(ref T target, ref bool initialized, ref object syncLock);
+        public static T EnsureInitialized<T>(ref T target, ref bool initialized, ref object syncLock, Func<T> valueFactory);
+        public static T EnsureInitialized<T>(ref T target, Func<T> valueFactory) where T : class;
+    }
+    public enum LazyThreadSafetyMode {
+        ExecutionAndPublication = 2,
+        None = 0,
+        PublicationOnly = 1,
+    }
+    public class LockRecursionException : Exception {
+        public LockRecursionException();
+        public LockRecursionException(string message);
+        public LockRecursionException(string message, Exception innerException);
+    }
+    public enum LockRecursionPolicy {
+        NoRecursion = 0,
+        SupportsRecursion = 1,
+    }
+    public sealed class ManualResetEvent : EventWaitHandle {
+        public ManualResetEvent(bool initialState);
+    }
+    public class ManualResetEventSlim : IDisposable {
+        public ManualResetEventSlim();
+        public ManualResetEventSlim(bool initialState);
+        public ManualResetEventSlim(bool initialState, int spinCount);
+        public bool IsSet { get; }
+        public int SpinCount { get; }
+        public WaitHandle WaitHandle { get; }
+        public void Dispose();
+        protected virtual void Dispose(bool disposing);
+        public void Reset();
+        public void Set();
+        public void Wait();
+        public bool Wait(int millisecondsTimeout);
+        public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken);
+        public void Wait(CancellationToken cancellationToken);
+        public bool Wait(TimeSpan timeout);
+        public bool Wait(TimeSpan timeout, CancellationToken cancellationToken);
+    }
+    public static class Monitor {
+        public static void Enter(object obj);
+        public static void Enter(object obj, ref bool lockTaken);
+        public static void Exit(object obj);
+        public static bool IsEntered(object obj);
+        public static void Pulse(object obj);
+        public static void PulseAll(object obj);
+        public static bool TryEnter(object obj);
+        public static void TryEnter(object obj, ref bool lockTaken);
+        public static bool TryEnter(object obj, int millisecondsTimeout);
+        public static void TryEnter(object obj, int millisecondsTimeout, ref bool lockTaken);
+        public static bool TryEnter(object obj, TimeSpan timeout);
+        public static void TryEnter(object obj, TimeSpan timeout, ref bool lockTaken);
+        public static bool Wait(object obj);
+        public static bool Wait(object obj, int millisecondsTimeout);
+        public static bool Wait(object obj, TimeSpan timeout);
+    }
+    public sealed class Mutex : WaitHandle {
+        public Mutex();
+        public Mutex(bool initiallyOwned);
+        public Mutex(bool initiallyOwned, string name);
+        public Mutex(bool initiallyOwned, string name, out bool createdNew);
+        public static Mutex OpenExisting(string name);
+        public void ReleaseMutex();
+        public static bool TryOpenExisting(string name, out Mutex result);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct NativeOverlapped {
+        public int OffsetHigh;
+        public int OffsetLow;
+        public IntPtr EventHandle;
+        public IntPtr InternalHigh;
+        public IntPtr InternalLow;
+    }
+    public class Overlapped {
+        public Overlapped();
+        public IAsyncResult AsyncResult { get; set; }
+        public int OffsetHigh { get; set; }
+        public int OffsetLow { get; set; }
+        public unsafe static void Free(NativeOverlapped* nativeOverlappedPtr);
+        public unsafe NativeOverlapped* Pack(IOCompletionCallback iocb, object userData);
+        public unsafe static Overlapped Unpack(NativeOverlapped* nativeOverlappedPtr);
+        public unsafe NativeOverlapped* UnsafePack(IOCompletionCallback iocb, object userData);
+    }
+    public delegate void ParameterizedThreadStart(object obj);
+    public sealed class PreAllocatedOverlapped : IDisposable {
+        public PreAllocatedOverlapped(IOCompletionCallback callback, object state, object pinData);
+        public void Dispose();
+    }
+    public class ReaderWriterLockSlim : IDisposable {
+        public ReaderWriterLockSlim();
+        public ReaderWriterLockSlim(LockRecursionPolicy recursionPolicy);
+        public int CurrentReadCount { get; }
+        public bool IsReadLockHeld { get; }
+        public bool IsUpgradeableReadLockHeld { get; }
+        public bool IsWriteLockHeld { get; }
+        public LockRecursionPolicy RecursionPolicy { get; }
+        public int RecursiveReadCount { get; }
+        public int RecursiveUpgradeCount { get; }
+        public int RecursiveWriteCount { get; }
+        public int WaitingReadCount { get; }
+        public int WaitingUpgradeCount { get; }
+        public int WaitingWriteCount { get; }
+        public void Dispose();
+        public void EnterReadLock();
+        public void EnterUpgradeableReadLock();
+        public void EnterWriteLock();
+        public void ExitReadLock();
+        public void ExitUpgradeableReadLock();
+        public void ExitWriteLock();
+        public bool TryEnterReadLock(int millisecondsTimeout);
+        public bool TryEnterReadLock(TimeSpan timeout);
+        public bool TryEnterUpgradeableReadLock(int millisecondsTimeout);
+        public bool TryEnterUpgradeableReadLock(TimeSpan timeout);
+        public bool TryEnterWriteLock(int millisecondsTimeout);
+        public bool TryEnterWriteLock(TimeSpan timeout);
+    }
+    public sealed class RegisteredWaitHandle {
+        public bool Unregister(WaitHandle waitObject);
+    }
+    public sealed class Semaphore : WaitHandle {
+        public Semaphore(int initialCount, int maximumCount);
+        public Semaphore(int initialCount, int maximumCount, string name);
+        public Semaphore(int initialCount, int maximumCount, string name, out bool createdNew);
+        public static Semaphore OpenExisting(string name);
+        public int Release();
+        public int Release(int releaseCount);
+        public static bool TryOpenExisting(string name, out Semaphore result);
+    }
+    public class SemaphoreFullException : Exception {
+        public SemaphoreFullException();
+        public SemaphoreFullException(string message);
+        public SemaphoreFullException(string message, Exception innerException);
+    }
+    public class SemaphoreSlim : IDisposable {
+        public SemaphoreSlim(int initialCount);
+        public SemaphoreSlim(int initialCount, int maxCount);
+        public WaitHandle AvailableWaitHandle { get; }
+        public int CurrentCount { get; }
+        public void Dispose();
+        protected virtual void Dispose(bool disposing);
+        public int Release();
+        public int Release(int releaseCount);
+        public void Wait();
+        public bool Wait(int millisecondsTimeout);
+        public bool Wait(int millisecondsTimeout, CancellationToken cancellationToken);
+        public void Wait(CancellationToken cancellationToken);
+        public bool Wait(TimeSpan timeout);
+        public bool Wait(TimeSpan timeout, CancellationToken cancellationToken);
+        public Task WaitAsync();
+        public Task<bool> WaitAsync(int millisecondsTimeout);
+        public Task<bool> WaitAsync(int millisecondsTimeout, CancellationToken cancellationToken);
+        public Task WaitAsync(CancellationToken cancellationToken);
+        public Task<bool> WaitAsync(TimeSpan timeout);
+        public Task<bool> WaitAsync(TimeSpan timeout, CancellationToken cancellationToken);
+    }
+    public delegate void SendOrPostCallback(object state);
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct SpinLock {
+        public SpinLock(bool enableThreadOwnerTracking);
+        public bool IsHeld { get; }
+        public bool IsHeldByCurrentThread { get; }
+        public bool IsThreadOwnerTrackingEnabled { get; }
+        public void Enter(ref bool lockTaken);
+        public void Exit();
+        public void Exit(bool useMemoryBarrier);
+        public void TryEnter(ref bool lockTaken);
+        public void TryEnter(int millisecondsTimeout, ref bool lockTaken);
+        public void TryEnter(TimeSpan timeout, ref bool lockTaken);
+    }
+    [System.Runtime.InteropServices.StructLayoutAttribute(System.Runtime.InteropServices.LayoutKind.Sequential)]
+    public struct SpinWait {
+        public int Count { get; }
+        public bool NextSpinWillYield { get; }
+        public void Reset();
+        public void SpinOnce();
+        public static void SpinUntil(Func<bool> condition);
+        public static bool SpinUntil(Func<bool> condition, int millisecondsTimeout);
+        public static bool SpinUntil(Func<bool> condition, TimeSpan timeout);
+    }
+    public class SynchronizationContext {
+        public SynchronizationContext();
+        public static SynchronizationContext Current { get; }
+        public virtual SynchronizationContext CreateCopy();
+        public virtual void OperationCompleted();
+        public virtual void OperationStarted();
+        public virtual void Post(SendOrPostCallback d, object state);
+        public virtual void Send(SendOrPostCallback d, object state);
+        public static void SetSynchronizationContext(SynchronizationContext syncContext);
+    }
+    public class SynchronizationLockException : Exception {
+        public SynchronizationLockException();
+        public SynchronizationLockException(string message);
+        public SynchronizationLockException(string message, Exception innerException);
+    }
+    public sealed class Thread {
+        public Thread(ParameterizedThreadStart start);
+        public Thread(ThreadStart start);
+        public CultureInfo CurrentCulture { get; set; }
+        public static Thread CurrentThread { get; }
+        public CultureInfo CurrentUICulture { get; set; }
+        public bool IsAlive { get; }
+        public bool IsBackground { get; set; }
+        public int ManagedThreadId { get; }
+        public string Name { get; set; }
+        public ThreadState ThreadState { get; }
+        ~Thread();
+        public static AppDomain GetDomain();
+        public override int GetHashCode();
+        public void Join();
+        public bool Join(int millisecondsTimeout);
+        [MethodImpl(InternalCall)]public static void MemoryBarrier();
+        public static void Sleep(int millisecondsTimeout);
+        public static void Sleep(TimeSpan timeout);
+        public static void SpinWait(int iterations);
+        public void Start();
+        public void Start(object parameter);
+    }
+    public sealed class ThreadAbortException : SystemException
+    public static class ThreadingAclExtensions {
+        public static EventWaitHandleSecurity GetAccessControl(this EventWaitHandle handle);
+        public static MutexSecurity GetAccessControl(this Mutex mutex);
+        public static SemaphoreSecurity GetAccessControl(this Semaphore semaphore);
+        public static void SetAccessControl(this EventWaitHandle handle, EventWaitHandleSecurity eventSecurity);
+        public static void SetAccessControl(this Mutex mutex, MutexSecurity mutexSecurity);
+        public static void SetAccessControl(this Semaphore semaphore, SemaphoreSecurity semaphoreSecurity);
+    }
+    public class ThreadLocal<T> : IDisposable {
+        public ThreadLocal();
+        public ThreadLocal(bool trackAllValues);
+        public ThreadLocal(Func<T> valueFactory);
+        public ThreadLocal(Func<T> valueFactory, bool trackAllValues);
+        public bool IsValueCreated { get; }
+        public T Value { get; set; }
+        public IList<T> Values { get; }
+        public void Dispose();
+        protected virtual void Dispose(bool disposing);
+        ~ThreadLocal();
+        public override string ToString();
+    }
+    public static class ThreadPool {
+        public static bool BindHandle(SafeHandle osHandle);
+        public static void GetMaxThreads(out int workerThreads, out int completionPortThreads);
+        public static void GetMinThreads(out int workerThreads, out int completionPortThreads);
+        public static bool QueueUserWorkItem(WaitCallback callBack);
+        public static bool QueueUserWorkItem(WaitCallback callBack, object state);
+        public static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, object state, int millisecondsTimeOutInterval, bool executeOnlyOnce);
+        public static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, object state, long millisecondsTimeOutInterval, bool executeOnlyOnce);
+        public static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, object state, TimeSpan timeout, bool executeOnlyOnce);
+        public static RegisteredWaitHandle RegisterWaitForSingleObject(WaitHandle waitObject, WaitOrTimerCallback callBack, object state, uint millisecondsTimeOutInterval, bool executeOnlyOnce);
+        public static bool SetMaxThreads(int workerThreads, int completionPortThreads);
+        public static bool SetMinThreads(int workerThreads, int completionPortThreads);
+    }
+    public sealed class ThreadPoolBoundHandle : IDisposable {
+        public SafeHandle Handle { get; }
+        public unsafe NativeOverlapped* AllocateNativeOverlapped(IOCompletionCallback callback, object state, object pinData);
+        public unsafe NativeOverlapped* AllocateNativeOverlapped(PreAllocatedOverlapped preAllocated);
+        public static ThreadPoolBoundHandle BindHandle(SafeHandle handle);
+        public void Dispose();
+        public unsafe void FreeNativeOverlapped(NativeOverlapped* overlapped);
+        public unsafe static object GetNativeOverlappedState(NativeOverlapped* overlapped);
+    }
+    public delegate void ThreadStart();
+    public sealed class ThreadStartException : Exception
+    public enum ThreadState {
+        Aborted = 256,
+        AbortRequested = 128,
+        Background = 4,
+        Running = 0,
+        Stopped = 16,
+        StopRequested = 1,
+        Suspended = 64,
+        SuspendRequested = 2,
+        Unstarted = 8,
+        WaitSleepJoin = 32,
+    }
+    public class ThreadStateException : Exception {
+        public ThreadStateException();
+        public ThreadStateException(string message);
+        public ThreadStateException(string message, Exception innerException);
+    }
+    public static class Timeout {
+        public const int Infinite = -1;
+        public static readonly TimeSpan InfiniteTimeSpan;
+    }
+    public sealed class Timer : IDisposable {
+        [MethodImpl(NoInlining)]public Timer(TimerCallback callback);
+        public Timer(TimerCallback callback, object state, int dueTime, int period);
+        [MethodImpl(NoInlining)]public Timer(TimerCallback callback, object state, long dueTime, long period);
+        public Timer(TimerCallback callback, object state, TimeSpan dueTime, TimeSpan period);
+        [MethodImpl(NoInlining)]public Timer(TimerCallback callback, object state, uint dueTime, uint period);
+        public bool Change(int dueTime, int period);
+        public bool Change(long dueTime, long period);
+        public bool Change(TimeSpan dueTime, TimeSpan period);
+        public bool Change(uint dueTime, uint period);
+        public void Dispose();
+        public bool Dispose(WaitHandle notifyObject);
+    }
+    public delegate void TimerCallback(object state);
+    public static class Volatile {
+        public static bool Read(ref bool location);
+        public static byte Read(ref byte location);
+        public static double Read(ref double location);
+        public static short Read(ref short location);
+        public static int Read(ref int location);
+        public static long Read(ref long location);
+        public static IntPtr Read(ref IntPtr location);
+        public static sbyte Read(ref sbyte location);
+        public static float Read(ref float location);
+        public static ushort Read(ref ushort location);
+        public static uint Read(ref uint location);
+        public static ulong Read(ref ulong location);
+        public static UIntPtr Read(ref UIntPtr location);
+        public static T Read<T>(ref T location) where T : class;
+        public static void Write(ref bool location, bool value);
+        public static void Write(ref byte location, byte value);
+        public static void Write(ref double location, double value);
+        public static void Write(ref short location, short value);
+        public static void Write(ref int location, int value);
+        public static void Write(ref long location, long value);
+        public static void Write(ref IntPtr location, IntPtr value);
+        public static void Write(ref sbyte location, sbyte value);
+        public static void Write(ref float location, float value);
+        public static void Write(ref ushort location, ushort value);
+        public static void Write(ref uint location, uint value);
+        public static void Write(ref ulong location, ulong value);
+        public static void Write(ref UIntPtr location, UIntPtr value);
+        public static void Write<T>(ref T location, T value) where T : class;
+    }
+    public delegate void WaitCallback(object state);
+    public abstract class WaitHandle : IDisposable {
+        public const int WaitTimeout = 258;
+        protected static readonly IntPtr InvalidHandle;
+        protected WaitHandle();
+        public SafeWaitHandle SafeWaitHandle { get; set; }
+        public virtual void Close();
+        public void Dispose();
+        protected virtual void Dispose(bool explicitDisposing);
+        public static bool WaitAll(WaitHandle[] waitHandles);
+        public static bool WaitAll(WaitHandle[] waitHandles, int millisecondsTimeout);
+        public static bool WaitAll(WaitHandle[] waitHandles, TimeSpan timeout);
+        public static int WaitAny(WaitHandle[] waitHandles);
+        public static int WaitAny(WaitHandle[] waitHandles, int millisecondsTimeout);
+        public static int WaitAny(WaitHandle[] waitHandles, TimeSpan timeout);
+        public virtual bool WaitOne();
+        public virtual bool WaitOne(int millisecondsTimeout);
+        public virtual bool WaitOne(TimeSpan timeout);
+    }
+    public class WaitHandleCannotBeOpenedException : Exception {
+        public WaitHandleCannotBeOpenedException();
+        public WaitHandleCannotBeOpenedException(string message);
+        public WaitHandleCannotBeOpenedException(string message, Exception innerException);
+    }
+    public static class WaitHandleExtensions {
+        public static SafeWaitHandle GetSafeWaitHandle(this WaitHandle waitHandle);
+        public static void SetSafeWaitHandle(this WaitHandle waitHandle, SafeWaitHandle value);
+    }
+    public delegate void WaitOrTimerCallback(object state, bool timedOut);
+}
```