1 files changed, 53 insertions, 11 deletions

diff --git a/OpenSim/Framework/Util.cs b/OpenSim/Framework/Util.cs
index 7dde6dd..d09bd6d 100644
--- a/OpenSim/Framework/Util.cs
+++ b/OpenSim/Framework/Util.cs
@@ -53,6 +53,18 @@ using Amib.Threading;
 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
@@ -74,7 +86,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.SmartThreadPool;
+
         /// <summary>
         /// Linear interpolates B<->C using percent A
         /// </summary>
@@ -1277,7 +1291,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)
             {
@@ -1288,17 +1302,28 @@ 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 SetMaxThreads(int maxThreads)
         {
+            if (m_ThreadPool != null)
+                return;
+
             STPStartInfo startInfo = new STPStartInfo();
             startInfo.IdleTimeout = 2000; // 2 seconds
             startInfo.MaxWorkerThreads = maxThreads;
@@ -1313,11 +1338,28 @@ namespace OpenSim.Framework
 
         public static void FireAndForget(System.Threading.WaitCallback callback, object obj)
         {
-            m_ThreadPool.QueueWorkItem(new WorkItemCallback(delegate(object o)
-                {
-                    callback(o);
-                    return null;
-                }), 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:
+                    m_ThreadPool.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();
+            }
         }
 
         #endregion FireAndForget Threading Pattern