3 files changed, 55 insertions, 23 deletions

diff --git a/OpenSim/Framework/Communications/RestClient.cs b/OpenSim/Framework/Communications/RestClient.cs
index 317b3a0..97b3b60 100644
--- a/OpenSim/Framework/Communications/RestClient.cs
+++ b/OpenSim/Framework/Communications/RestClient.cs
@@ -403,7 +403,7 @@ namespace OpenSim.Framework.Communications
             /// In case, we are invoked asynchroneously this object will keep track of the state
             /// </summary>
             AsyncResult<Stream> ar = new AsyncResult<Stream>(callback, state);
-            ThreadPool.UnsafeQueueUserWorkItem(RequestHelper, ar);
+            Util.FireAndForget(RequestHelper, ar);
             return ar;
         }
 
diff --git a/OpenSim/Framework/Parallel.cs b/OpenSim/Framework/Parallel.cs
index ab2e108..70eecdc 100644
--- a/OpenSim/Framework/Parallel.cs
+++ b/OpenSim/Framework/Parallel.cs
@@ -66,7 +66,7 @@ namespace OpenSim.Framework
 
             for (int i = 0; i < threadCount; i++)
             {
-                ThreadPool.UnsafeQueueUserWorkItem(
+                Util.FireAndForget(
                     delegate(object o)
                     {
                         int threadIndex = (int)o;
@@ -122,7 +122,7 @@ namespace OpenSim.Framework
 
             for (int i = 0; i < threadCount; i++)
             {
-                ThreadPool.UnsafeQueueUserWorkItem(
+                Util.FireAndForget(
                     delegate(object o)
                     {
                         int threadIndex = (int)o;
@@ -178,7 +178,7 @@ namespace OpenSim.Framework
 
             for (int i = 0; i < threadCount; i++)
             {
-                ThreadPool.UnsafeQueueUserWorkItem(
+                Util.FireAndForget(
                     delegate(object o)
                     {
                         int threadIndex = (int)o;
diff --git a/OpenSim/Framework/Util.cs b/OpenSim/Framework/Util.cs
index d5ae3b7..02f6d12 100644
--- a/OpenSim/Framework/Util.cs
+++ b/OpenSim/Framework/Util.cs
@@ -51,6 +51,18 @@ using OpenMetaverse.StructuredData;
 namespace OpenSim.Framework
 {
     /// <summary>
+    /// The method used by Util.FireAndForget for asynchronously firing events
+    /// </summary>
+    public enum FireAndForgetMethod
+    {
+        UnsafeQueueUserWorkItem,
+        QueueUserWorkItem,
+        BeginInvoke,
+        SmartThreadPool,
+        Thread,
+    }
+
+    /// <summary>
     /// Miscellaneous utility functions
     /// </summary>
     public class Util
@@ -70,7 +82,9 @@ namespace OpenSim.Framework
 
         public static readonly Regex UUIDPattern 
             = new Regex("^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$");
-        
+
+        public static FireAndForgetMethod FireAndForgetMethod = FireAndForgetMethod.UnsafeQueueUserWorkItem;
+
         /// <summary>
         /// Linear interpolates B<->C using percent A
         /// </summary>
@@ -1273,7 +1287,7 @@ namespace OpenSim.Framework
         /// <summary>
         /// Created to work around a limitation in Mono with nested delegates
         /// </summary>
-        /*private class FireAndForgetWrapper
+        private class FireAndForgetWrapper
         {
             public void FireAndForget(System.Threading.WaitCallback callback)
             {
@@ -1284,32 +1298,50 @@ namespace OpenSim.Framework
             {
                 callback.BeginInvoke(obj, EndFireAndForget, callback);
             }
-        }*/
+
+            private static void EndFireAndForget(IAsyncResult ar)
+            {
+                System.Threading.WaitCallback callback = (System.Threading.WaitCallback)ar.AsyncState;
+
+                try { callback.EndInvoke(ar); }
+                catch (Exception ex) { m_log.Error("[UTIL]: Asynchronous method threw an exception: " + ex.Message, ex); }
+
+                ar.AsyncWaitHandle.Close();
+            }
+        }
 
         public static void FireAndForget(System.Threading.WaitCallback callback)
         {
-            //FireAndForgetWrapper wrapper = Singleton.GetInstance<FireAndForgetWrapper>();
-            //wrapper.FireAndForget(callback);
-            System.Threading.ThreadPool.UnsafeQueueUserWorkItem(callback, null);
+            FireAndForget(callback, null);
         }
 
         public static void FireAndForget(System.Threading.WaitCallback callback, object obj)
         {
-            //FireAndForgetWrapper wrapper = Singleton.GetInstance<FireAndForgetWrapper>();
-            //wrapper.FireAndForget(callback, obj);
-            System.Threading.ThreadPool.UnsafeQueueUserWorkItem(callback, obj);
+            switch (FireAndForgetMethod)
+            {
+                case FireAndForgetMethod.UnsafeQueueUserWorkItem:
+                    System.Threading.ThreadPool.UnsafeQueueUserWorkItem(callback, obj);
+                    break;
+                case FireAndForgetMethod.QueueUserWorkItem:
+                    System.Threading.ThreadPool.QueueUserWorkItem(callback, obj);
+                    break;
+                case FireAndForgetMethod.BeginInvoke:
+                    FireAndForgetWrapper wrapper = Singleton.GetInstance<FireAndForgetWrapper>();
+                    wrapper.FireAndForget(callback, obj);
+                    break;
+                case FireAndForgetMethod.SmartThreadPool:
+                    Amib.Threading.SmartThreadPool stp = Singleton.GetInstance<Amib.Threading.SmartThreadPool>();
+                    stp.QueueWorkItem(delegate(object o) { callback(o); return null; }, obj);
+                    break;
+                case FireAndForgetMethod.Thread:
+                    System.Threading.Thread thread = new System.Threading.Thread(delegate(object o) { callback(o); });
+                    thread.Start(obj);
+                    break;
+                default:
+                    throw new NotImplementedException();
+            }
         }
 
-        /*private static void EndFireAndForget(IAsyncResult ar)
-        {
-            System.Threading.WaitCallback callback = (System.Threading.WaitCallback)ar.AsyncState;
-
-            try { callback.EndInvoke(ar); }
-            catch (Exception ex) { m_log.Error("[UTIL]: Asynchronous method threw an exception: " + ex.Message, ex); }
-
-            ar.AsyncWaitHandle.Close();
-        }*/
-
         #endregion FireAndForget Threading Pattern
     }
 }