mcs/class/corlib/System.Threading/ThreadPool.cs

   1 //
   2 // System.Threading.ThreadPool
   3 //
   4 // Author:
   5 //   Patrik Torstensson
   6 //   Dick Porter (dick@ximian.com)
   7 //   Maurer Dietmar (dietmar@ximian.com)
   8 //
   9 // (C) Ximian, Inc.  http://www.ximian.com
  10 //
  11 using System;
  12 using System.Collections;
  13 using System.Runtime.CompilerServices;
  14
  15 namespace System.Threading {
  16
  17         public sealed class ThreadPool {
  18
  19                 private ThreadPool ()
  20                 {
  21                         /* nothing to do */
  22                 }
  23
  24                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
  25                 static extern bool BindHandleInternal (IntPtr osHandle);
  26
  27                 public static bool BindHandle (IntPtr osHandle)
  28                 {
  29                         return BindHandleInternal (osHandle);
  30                 }
  31
  32                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
  33                 public static extern void GetAvailableThreads (out int workerThreads, out int completionPortThreads);
  34
  35                 [MethodImplAttribute(MethodImplOptions.InternalCall)]
  36                 public static extern void GetMaxThreads (out int workerThreads, out int completionPortThreads);
  37
  38                 public static bool QueueUserWorkItem (WaitCallback callback)
  39                 {
  40                         IAsyncResult ar = callback.BeginInvoke (null, null, null);
  41                         if (ar == null)
  42                                 return false;
  43                         return true;
  44                 }
  45
  46                 public static bool QueueUserWorkItem (WaitCallback callback, object state)
  47                 {
  48                         IAsyncResult ar = callback.BeginInvoke (state, null, null);
  49                         if (ar == null)
  50                                 return false;
  51                         return true;
  52                 }
  53
  54                 public static RegisteredWaitHandle RegisterWaitForSingleObject (WaitHandle waitObject,
  55                                                                                 WaitOrTimerCallback callBack,
  56                                                                                 object state,
  57                                                                                 int millisecondsTimeOutInterval,
  58                                                                                 bool executeOnlyOnce)
  59                 {
  60                         return RegisterWaitForSingleObject (waitObject, callBack, state,
  61                                                             (long) millisecondsTimeOutInterval, executeOnlyOnce);
  62                 }
  63
  64                 public static RegisteredWaitHandle RegisterWaitForSingleObject (WaitHandle waitObject,
  65                                                                                 WaitOrTimerCallback callBack,
  66                                                                                 object state,
  67                                                                                 long millisecondsTimeOutInterval,
  68                                                                                 bool executeOnlyOnce)
  69                 {
  70                         if (millisecondsTimeOutInterval < -1)
  71                                 throw new ArgumentOutOfRangeException ("timeout", "timeout < -1");
  72
  73                         if (millisecondsTimeOutInterval > Int32.MaxValue)
  74                                 throw new NotSupportedException ("Timeout is too big. Maximum is Int32.MaxValue");
  75
  76                         TimeSpan timeout = new TimeSpan (0, 0, 0, 0, (int) millisecondsTimeOutInterval);
  77
  78                         RegisteredWaitHandle waiter = new RegisteredWaitHandle (waitObject, callBack, state,
  79                                                                                 timeout, executeOnlyOnce);
  80                         QueueUserWorkItem (new WaitCallback (waiter.Wait), null);
  81                         return waiter;
  82                 }
  83
  84                 public static RegisteredWaitHandle RegisterWaitForSingleObject (WaitHandle waitObject,
  85                                                                                 WaitOrTimerCallback callBack,
  86                                                                                 object state,
  87                                                                                 TimeSpan timeout,
  88                                                                                 bool executeOnlyOnce)
  89                 {
  90                         return RegisterWaitForSingleObject (waitObject, callBack, state,
  91                                                             (long) timeout.TotalMilliseconds, executeOnlyOnce);
  92
  93                 }
  94
  95                 [CLSCompliant(false)]
  96                 public static RegisteredWaitHandle RegisterWaitForSingleObject (WaitHandle waitObject,
  97                                                                                 WaitOrTimerCallback callBack,
  98                                                                                 object state,
  99                                                                                 uint millisecondsTimeOutInterval,
 100                                                                                 bool executeOnlyOnce)
 101                 {
 102                         return RegisterWaitForSingleObject (waitObject, callBack, state,
 103                                                             (long) millisecondsTimeOutInterval, executeOnlyOnce);
 104                 }
 105
 106                 public static bool UnsafeQueueUserWorkItem (WaitCallback callback, object state)
 107                 {
 108                         IAsyncResult ar = callback.BeginInvoke (state, null, null);
 109                         if (ar == null)
 110                                 return false;
 111                         return true;
 112                 }
 113
 114         }
 115 }