21 files changed, 546 insertions, 98 deletions

diff --git a/src/shared/CMakeLists.txt b/src/shared/CMakeLists.txt
index 8ecfccad34f..b271e2b9545 100644
--- a/src/shared/CMakeLists.txt
+++ b/src/shared/CMakeLists.txt
@@ -14,6 +14,7 @@ SET(shared_STAT_SRCS
    Log.h
    ProgressBar.cpp
    ProgressBar.h
+   Threading.cpp
    Timer.h
    Util.cpp
    Util.h
@@ -22,3 +23,7 @@ SET(shared_STAT_SRCS
 )
 
 add_library(shared STATIC ${shared_STAT_SRCS})
+target_link_libraries(
+shared
+${ACE_LIBRARY}
+)
diff --git a/src/shared/Common.h b/src/shared/Common.h
index abe804bb3a4..37ced4c8e11 100644
--- a/src/shared/Common.h
+++ b/src/shared/Common.h
@@ -62,26 +62,17 @@
 #include "Platform/Define.h"
 
 #if COMPILER == COMPILER_MICROSOFT
-
-#pragma warning(disable:4996)
-
+#   pragma warning(disable:4996)                            // 'function': was declared deprecated
 #ifndef __SHOW_STUPID_WARNINGS__
-
-#pragma warning(disable:4244)
-
-#pragma warning(disable:4267)
-
-#pragma warning(disable:4800)
-
-#pragma warning(disable:4018)
-
-#pragma warning(disable:4311)
-
-#pragma warning(disable:4305)
-
-#pragma warning(disable:4005)
-
-#pragma warning(disable:4522)//warning when class has 2 constructosr
+#   pragma warning(disable:4005)                            // 'identifier' : macro redefinition
+#   pragma warning(disable:4018)                            // 'expression' : signed/unsigned mismatch
+#   pragma warning(disable:4244)                            // 'argument' : conversion from 'type1' to 'type2', possible loss of data
+#   pragma warning(disable:4267)                            // 'var' : conversion from 'size_t' to 'type', possible loss of data
+#   pragma warning(disable:4305)                            // 'identifier' : truncation from 'type1' to 'type2'
+#   pragma warning(disable:4311)                            // 'variable' : pointer truncation from 'type' to 'type'
+#   pragma warning(disable:4355)                            // 'this' : used in base member initializer list
+#   pragma warning(disable:4800)                            // 'type' : forcing value to bool 'true' or 'false' (performance warning)
+#   pragma warning(disable:4522)                            //warning when class has 2 constructosr
 #endif                                                      // __SHOW_STUPID_WARNINGS__
 #endif                                                      // __GNUC__
 
@@ -93,6 +84,7 @@
 #include <math.h>
 #include <errno.h>
 #include <signal.h>
+#include <assert.h>
 
 #if PLATFORM == PLATFORM_WINDOWS
 #define STRCASECMP stricmp
@@ -108,10 +100,13 @@
 #include <sstream>
 #include <algorithm>
 
-#include <zthread/FastMutex.h>
-#include <zthread/LockedQueue.h>
-#include <zthread/Runnable.h>
-#include <zthread/Thread.h>
+#include "LockedQueue.h"
+#include "Threading.h"
+
+#include <ace/Guard_T.h>
+#include <ace/RW_Thread_Mutex.h>
+#include <ace/Thread_Mutex.h>
+
 
 #if PLATFORM == PLATFORM_WINDOWS
 #  define FD_SETSIZE 4096
diff --git a/src/shared/Database/Database.cpp b/src/shared/Database/Database.cpp
index 07ece3b0cd9..d5ccc581232 100644
--- a/src/shared/Database/Database.cpp
+++ b/src/shared/Database/Database.cpp
@@ -110,7 +110,8 @@ bool Database::PExecuteLog(const char * format,...)
 
 void Database::SetResultQueue(SqlResultQueue * queue)
 {
-    m_queryQueues[ZThread::ThreadImpl::current()] = queue;
+    m_queryQueues[ACE_Based::Thread::current()] = queue;
+
 }
 
 QueryResult* Database::PQuery(const char *format,...)
diff --git a/src/shared/Database/Database.h b/src/shared/Database/Database.h
index 92a1c991dcc..a9f7285c223 100644
--- a/src/shared/Database/Database.h
+++ b/src/shared/Database/Database.h
@@ -21,8 +21,7 @@
 #ifndef DATABASE_H
 #define DATABASE_H
 
-#include "zthread/Thread.h"
-#include "../src/zthread/ThreadImpl.h"
+#include "Threading.h"
 #include "Utilities/UnorderedMap.h"
 #include "Database/SqlDelayThread.h"
 
@@ -30,8 +29,8 @@ class SqlTransaction;
 class SqlResultQueue;
 class SqlQueryHolder;
 
-typedef UNORDERED_MAP<ZThread::ThreadImpl*, SqlTransaction*> TransactionQueues;
-typedef UNORDERED_MAP<ZThread::ThreadImpl*, SqlResultQueue*> QueryQueues;
+typedef UNORDERED_MAP<ACE_Based::Thread* , SqlTransaction*> TransactionQueues;
+typedef UNORDERED_MAP<ACE_Based::Thread* , SqlResultQueue*> QueryQueues;
 
 #define MAX_QUERY_LEN   32*1024
 
@@ -43,7 +42,7 @@ class TRINITY_DLL_SPEC Database
         TransactionQueues m_tranQueues;                     ///< Transaction queues from diff. threads
         QueryQueues m_queryQueues;                          ///< Query queues from diff threads
         SqlDelayThread* m_threadBody;                       ///< Pointer to delay sql executer
-        ZThread::Thread* m_delayThread;                     ///< Pointer to executer thread
+        ACE_Based::Thread* m_delayThread;                   ///< Pointer to executer thread
 
     public:
 
diff --git a/src/shared/Database/DatabaseImpl.h b/src/shared/Database/DatabaseImpl.h
index 3d3c53f0873..7cbd0ed8ba5 100644
--- a/src/shared/Database/DatabaseImpl.h
+++ b/src/shared/Database/DatabaseImpl.h
@@ -29,7 +29,7 @@
     QueryQueues::iterator queue_itr; \
     \
     { \
-        ZThread::ThreadImpl * queryThread = ZThread::ThreadImpl::current(); \
+        ACE_Based::Thread * queryThread = ACE_Based::Thread::current(); \
         queue_itr = m_queryQueues.find(queryThread); \
         if (queue_itr == m_queryQueues.end()) return false; \
     }
@@ -59,7 +59,7 @@
     QueryQueues::iterator queue_itr; \
     \
     { \
-        ZThread::ThreadImpl * queryThread = ZThread::ThreadImpl::current(); \
+        ACE_Based::Thread * queryThread = ACE_Based::Thread::current(); \
         queue_itr = m_queryQueues.find(queryThread); \
         if (queue_itr == m_queryQueues.end()) return false; \
     }
diff --git a/src/shared/Database/DatabaseMysql.cpp b/src/shared/Database/DatabaseMysql.cpp
index 5dc02c0a738..9574d3dc2ac 100644
--- a/src/shared/Database/DatabaseMysql.cpp
+++ b/src/shared/Database/DatabaseMysql.cpp
@@ -23,7 +23,7 @@
 #include "Util.h"
 #include "Policies/SingletonImp.h"
 #include "Platform/Define.h"
-#include "../src/zthread/ThreadImpl.h"
+#include "Threading.h"
 #include "DatabaseEnv.h"
 #include "Database/MySQLDelayThread.h"
 #include "Database/SqlOperations.h"
@@ -203,8 +203,8 @@ QueryResult* DatabaseMysql::Query(const char *sql)
 
     {
         // guarded block for thread-safe mySQL request
-        ZThread::Guard<ZThread::FastMutex> query_connection_guard(mMutex);
-        #ifdef TRINITY_DEBUG
+        ACE_Guard<ACE_Thread_Mutex> query_connection_guard(mMutex);
+        #ifdef MANGOS_DEBUG
         uint32 _s = getMSTime();
         #endif
         if(mysql_query(mMysql, sql))
@@ -251,7 +251,7 @@ bool DatabaseMysql::Execute(const char *sql)
     // don't use queued execution if it has not been initialized
     if (!m_threadBody) return DirectExecute(sql);
 
-    tranThread = ZThread::ThreadImpl::current();            // owner of this transaction
+    tranThread = ACE_Based::Thread::current();              // owner of this transaction
     TransactionQueues::iterator i = m_tranQueues.find(tranThread);
     if (i != m_tranQueues.end() && i->second != NULL)
     {                                                       // Statement for transaction
@@ -273,8 +273,9 @@ bool DatabaseMysql::DirectExecute(const char* sql)
 
     {
         // guarded block for thread-safe mySQL request
-        ZThread::Guard<ZThread::FastMutex> query_connection_guard(mMutex);
-        #ifdef TRINITY_DEBUG
+        ACE_Guard<ACE_Thread_Mutex> query_connection_guard(mMutex);
+
+        #ifdef MANGOS_DEBUG
         uint32 _s = getMSTime();
         #endif
         if(mysql_query(mMysql, sql))
@@ -318,8 +319,9 @@ bool DatabaseMysql::BeginTransaction()
     // don't use queued execution if it has not been initialized
     if (!m_threadBody)
     {
-        if (tranThread==ZThread::ThreadImpl::current())
+        if (tranThread == ACE_Based::Thread::current())
             return false;                                   // huh? this thread already started transaction
+
         mMutex.acquire();
         if (!_TransactionCmd("START TRANSACTION"))
         {
@@ -329,7 +331,7 @@ bool DatabaseMysql::BeginTransaction()
         return true;                                        // transaction started
     }
 
-    tranThread = ZThread::ThreadImpl::current();            // owner of this transaction
+    tranThread = ACE_Based::Thread::current();              // owner of this transaction
     TransactionQueues::iterator i = m_tranQueues.find(tranThread);
     if (i != m_tranQueues.end() && i->second != NULL)
         // If for thread exists queue and also contains transaction
@@ -349,7 +351,7 @@ bool DatabaseMysql::CommitTransaction()
     // don't use queued execution if it has not been initialized
     if (!m_threadBody)
     {
-        if (tranThread!=ZThread::ThreadImpl::current())
+        if (tranThread != ACE_Based::Thread::current())
             return false;
         bool _res = _TransactionCmd("COMMIT");
         tranThread = NULL;
@@ -357,7 +359,7 @@ bool DatabaseMysql::CommitTransaction()
         return _res;
     }
 
-    tranThread = ZThread::ThreadImpl::current();
+    tranThread = ACE_Based::Thread::current();
     TransactionQueues::iterator i = m_tranQueues.find(tranThread);
     if (i != m_tranQueues.end() && i->second != NULL)
     {
@@ -377,7 +379,7 @@ bool DatabaseMysql::RollbackTransaction()
     // don't use queued execution if it has not been initialized
     if (!m_threadBody)
     {
-        if (tranThread!=ZThread::ThreadImpl::current())
+        if (tranThread != ACE_Based::Thread::current())
             return false;
         bool _res = _TransactionCmd("ROLLBACK");
         tranThread = NULL;
@@ -385,7 +387,7 @@ bool DatabaseMysql::RollbackTransaction()
         return _res;
     }
 
-    tranThread = ZThread::ThreadImpl::current();
+    tranThread = ACE_Based::Thread::current();
     TransactionQueues::iterator i = m_tranQueues.find(tranThread);
     if (i != m_tranQueues.end() && i->second != NULL)
     {
@@ -408,7 +410,8 @@ void DatabaseMysql::InitDelayThread()
     assert(!m_delayThread);
 
     //New delay thread for delay execute
-    m_delayThread = new ZThread::Thread(m_threadBody = new MySQLDelayThread(this));
+    m_threadBody = new MySQLDelayThread(this);
+    m_delayThread = new ACE_Based::Thread(*m_threadBody);
 }
 
 void DatabaseMysql::HaltDelayThread()
diff --git a/src/shared/Database/DatabaseMysql.h b/src/shared/Database/DatabaseMysql.h
index 2fa157e75a5..7f5730f9579 100644
--- a/src/shared/Database/DatabaseMysql.h
+++ b/src/shared/Database/DatabaseMysql.h
@@ -25,7 +25,8 @@
 
 #include "Database.h"
 #include "Policies/Singleton.h"
-#include "zthread/FastMutex.h"
+#include "ace/Thread_Mutex.h"
+#include "ace/Guard_T.h"
 
 #ifdef WIN32
 #define FD_SETSIZE 1024
@@ -65,9 +66,9 @@ class TRINITY_DLL_SPEC DatabaseMysql : public Database
         // must be call before finish thread run
         void ThreadEnd();
     private:
-        ZThread::FastMutex mMutex;
+        ACE_Thread_Mutex mMutex;
 
-        ZThread::ThreadImpl* tranThread;
+        ACE_Based::Thread * tranThread;
 
         MYSQL *mMysql;
 
diff --git a/src/shared/Database/DatabasePostgre.cpp b/src/shared/Database/DatabasePostgre.cpp
index 79e1c87f5e3..12875b33200 100644
--- a/src/shared/Database/DatabasePostgre.cpp
+++ b/src/shared/Database/DatabasePostgre.cpp
@@ -23,7 +23,7 @@
 #include "Util.h"
 #include "Policies/SingletonImp.h"
 #include "Platform/Define.h"
-#include "../src/zthread/ThreadImpl.h"
+#include "Threading.h"
 #include "DatabaseEnv.h"
 #include "Database/PGSQLDelayThread.h"
 #include "Database/SqlOperations.h"
@@ -126,8 +126,8 @@ QueryResult* DatabasePostgre::Query(const char *sql)
     uint32 fieldCount = 0;
 
     // guarded block for thread-safe request
-    ZThread::Guard<ZThread::FastMutex> query_connection_guard(mMutex);
-    #ifdef TRINITY_DEBUG
+    ACE_Guard<ACE_Thread_Mutex> query_connection_guard(mMutex);
+    #ifdef MANGOS_DEBUG
     uint32 _s = getMSTime();
     #endif
     // Send the query
@@ -174,9 +174,10 @@ bool DatabasePostgre::Execute(const char *sql)
         return false;
 
     // don't use queued execution if it has not been initialized
-    if (!m_threadBody) return DirectExecute(sql);
+    if (!m_threadBody)
+        return DirectExecute(sql);
 
-    tranThread = ZThread::ThreadImpl::current();            // owner of this transaction
+    tranThread = ACE_Based::Thread::current();              // owner of this transaction
     TransactionQueues::iterator i = m_tranQueues.find(tranThread);
     if (i != m_tranQueues.end() && i->second != NULL)
     {                                                       // Statement for transaction
@@ -197,8 +198,8 @@ bool DatabasePostgre::DirectExecute(const char* sql)
         return false;
     {
         // guarded block for thread-safe  request
-        ZThread::Guard<ZThread::FastMutex> query_connection_guard(mMutex);
-        #ifdef TRINITY_DEBUG
+        ACE_Guard<ACE_Thread_Mutex> query_connection_guard(mMutex);
+        #ifdef MANGOS_DEBUG
         uint32 _s = getMSTime();
         #endif
         PGresult *res = PQexec(mPGconn, sql);
@@ -247,7 +248,7 @@ bool DatabasePostgre::BeginTransaction()
     // don't use queued execution if it has not been initialized
     if (!m_threadBody)
     {
-        if (tranThread==ZThread::ThreadImpl::current())
+        if (tranThread == ACE_Based::Thread::current())
             return false;                                   // huh? this thread already started transaction
         mMutex.acquire();
         if (!_TransactionCmd("START TRANSACTION"))
@@ -258,7 +259,7 @@ bool DatabasePostgre::BeginTransaction()
         return true;
     }
     // transaction started
-    tranThread = ZThread::ThreadImpl::current();            // owner of this transaction
+    tranThread = ACE_Based::Thread::current();              // owner of this transaction
     TransactionQueues::iterator i = m_tranQueues.find(tranThread);
     if (i != m_tranQueues.end() && i->second != NULL)
         // If for thread exists queue and also contains transaction
@@ -278,14 +279,14 @@ bool DatabasePostgre::CommitTransaction()
     // don't use queued execution if it has not been initialized
     if (!m_threadBody)
     {
-        if (tranThread!=ZThread::ThreadImpl::current())
+        if (tranThread != ACE_Based::Thread::current())
             return false;
         bool _res = _TransactionCmd("COMMIT");
         tranThread = NULL;
         mMutex.release();
         return _res;
     }
-    tranThread = ZThread::ThreadImpl::current();
+    tranThread = ACE_Based::Thread::current();
     TransactionQueues::iterator i = m_tranQueues.find(tranThread);
     if (i != m_tranQueues.end() && i->second != NULL)
     {
@@ -304,14 +305,14 @@ bool DatabasePostgre::RollbackTransaction()
     // don't use queued execution if it has not been initialized
     if (!m_threadBody)
     {
-        if (tranThread!=ZThread::ThreadImpl::current())
+        if (tranThread != ACE_Based::Thread::current())
             return false;
         bool _res = _TransactionCmd("ROLLBACK");
         tranThread = NULL;
         mMutex.release();
         return _res;
     }
-    tranThread = ZThread::ThreadImpl::current();
+    tranThread = ACE_Based::Thread::current();
     TransactionQueues::iterator i = m_tranQueues.find(tranThread);
     if (i != m_tranQueues.end() && i->second != NULL)
     {
@@ -334,7 +335,8 @@ void DatabasePostgre::InitDelayThread()
     assert(!m_delayThread);
 
     //New delay thread for delay execute
-    m_delayThread = new ZThread::Thread(m_threadBody = new PGSQLDelayThread(this));
+    m_threadBody = new PGSQLDelayThread(this);
+    m_delayThread = new ACE_Based::Thread(*m_threadBody);
 }
 
 void DatabasePostgre::HaltDelayThread()
diff --git a/src/shared/Database/DatabasePostgre.h b/src/shared/Database/DatabasePostgre.h
index c7242add572..53f0802f86c 100644
--- a/src/shared/Database/DatabasePostgre.h
+++ b/src/shared/Database/DatabasePostgre.h
@@ -22,7 +22,6 @@
 #define _DatabasePostgre_H
 
 #include "Policies/Singleton.h"
-#include "zthread/FastMutex.h"
 #include <stdarg.h>
 
 #ifdef WIN32
@@ -63,10 +62,8 @@ class DatabasePostgre : public Database
         // must be call before finish thread run
         void ThreadEnd();
     private:
-        ZThread::FastMutex mMutex;
-        ZThread::FastMutex tranMutex;
-
-        ZThread::ThreadImpl* tranThread;
+        ACE_Thread_Mutex mMutex;
+        ACE_Based::Thread * tranThread;
 
         PGconn *mPGconn;
 
diff --git a/src/shared/Database/QueryResult.h b/src/shared/Database/QueryResult.h
index 01da45ed281..39228dd4ba9 100644
--- a/src/shared/Database/QueryResult.h
+++ b/src/shared/Database/QueryResult.h
@@ -40,7 +40,7 @@ class TRINITY_DLL_SPEC QueryResult
                 if(iter->second == name)
                     return iter->first;
             }
-            assert(false && "unknown field name");
+            ASSERT(false && "unknown field name");
             return uint32(-1);
         }
 
diff --git a/src/shared/Database/SQLStorage.cpp b/src/shared/Database/SQLStorage.cpp
index 8561afc4a33..67091174c77 100644
--- a/src/shared/Database/SQLStorage.cpp
+++ b/src/shared/Database/SQLStorage.cpp
@@ -29,9 +29,9 @@ extern DatabaseMysql  WorldDatabase;
 
 const char CreatureInfosrcfmt[]="iiiiiisssiiiiiiiiiiffiffiiiiiiiiiiiffiiiiiiiiiiiiiiiiiiiiiiiisiifflliiis";
 const char CreatureInfodstfmt[]="iiiiiisssiiiiiiiiiiffiffiiiiiiiiiiiffiiiiiiiiiiiiiiiiiiiiiiiisiifflliiii";
-const char CreatureDataAddonInfofmt[]="iiiiiiiis";
+const char CreatureDataAddonInfofmt[]="iiiiiiis";
 const char CreatureModelfmt[]="iffbi";
-const char CreatureInfoAddonInfofmt[]="iiiiiiiis";
+const char CreatureInfoAddonInfofmt[]="iiiiiiis";
 const char EquipmentInfofmt[]="iiii";
 const char GameObjectInfosrcfmt[]="iiisssiifiiiiiiiiiiiiiiiiiiiiiiiis";
 const char GameObjectInfodstfmt[]="iiisssiifiiiiiiiiiiiiiiiiiiiiiiiii";
diff --git a/src/shared/Database/SqlDelayThread.cpp b/src/shared/Database/SqlDelayThread.cpp
index 27f58510a0a..9a92fd5dd63 100644
--- a/src/shared/Database/SqlDelayThread.cpp
+++ b/src/shared/Database/SqlDelayThread.cpp
@@ -37,7 +37,7 @@ void SqlDelayThread::run()
     {
         // if the running state gets turned off while sleeping
         // empty the queue before exiting
-        ZThread::Thread::sleep(10);
+        ACE_Based::Thread::Sleep(10);
         while (!m_sqlQueue.empty())
         {
             s = m_sqlQueue.next();
diff --git a/src/shared/Database/SqlDelayThread.h b/src/shared/Database/SqlDelayThread.h
index cbae0c1e5eb..3c24d3525b7 100644
--- a/src/shared/Database/SqlDelayThread.h
+++ b/src/shared/Database/SqlDelayThread.h
@@ -21,21 +21,22 @@
 #ifndef __SQLDELAYTHREAD_H
 #define __SQLDELAYTHREAD_H
 
-#include "zthread/Thread.h"
-#include "zthread/Runnable.h"
-#include "zthread/FastMutex.h"
-#include "zthread/LockedQueue.h"
+#include "ace/Thread_Mutex.h"
+#include "LockedQueue.h"
+#include "Threading.h"
+
 
 class Database;
 class SqlOperation;
 
-class SqlDelayThread : public ZThread::Runnable
+class SqlDelayThread : public ACE_Based::Runnable
 {
-    typedef ZThread::LockedQueue<SqlOperation*, ZThread::FastMutex> SqlQueue;
+    typedef ACE_Based::LockedQueue<SqlOperation*, ACE_Thread_Mutex> SqlQueue;
+
     private:
         SqlQueue m_sqlQueue;                                ///< Queue of SQL statements
         Database* m_dbEngine;                               ///< Pointer to used Database engine
-        bool m_running;
+        volatile bool m_running;
 
         SqlDelayThread();
     public:
diff --git a/src/shared/Database/SqlOperations.h b/src/shared/Database/SqlOperations.h
index 61eef4bb7c4..e91d83b6611 100644
--- a/src/shared/Database/SqlOperations.h
+++ b/src/shared/Database/SqlOperations.h
@@ -23,9 +23,8 @@
 
 #include "Common.h"
 
-#include "zthread/LockedQueue.h"
-#include "zthread/FastMutex.h"
-#include "zthread/Thread.h"
+#include "ace/Thread_Mutex.h"
+#include "LockedQueue.h"
 #include <queue>
 #include "Utilities/Callback.h"
 
@@ -72,7 +71,7 @@ class SqlResultQueue;                                       /// queue for thread
 class SqlQueryHolder;                                       /// groups several async quries
 class SqlQueryHolderEx;                                     /// points to a holder, added to the delay thread
 
-class SqlResultQueue : public ZThread::LockedQueue<Trinity::IQueryCallback*, ZThread::FastMutex>
+class SqlResultQueue : public ACE_Based::LockedQueue<MaNGOS::IQueryCallback* , ACE_Thread_Mutex>
 {
     public:
         SqlResultQueue() {}
diff --git a/src/shared/LockedQueue.h b/src/shared/LockedQueue.h
new file mode 100644
index 00000000000..b085dd09b83
--- /dev/null
+++ b/src/shared/LockedQueue.h
@@ -0,0 +1,144 @@
+/*
+ * Copyright (C) 2009 MaNGOS <http://getmangos.com/>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef LOCKEDQUEUE_H
+#define LOCKEDQUEUE_H
+
+#include <ace/Guard_T.h>
+#include <ace/Thread_Mutex.h>
+#include <deque>
+#include <assert.h>
+#include "Errors.h"
+
+namespace ACE_Based
+{
+
+    template <class T, class LockType, typename StorageType=std::deque<T> >
+        class LockedQueue
+    {
+
+        //! Serialize access to the Queue
+        LockType _lock;
+
+        //! Storage backing the queue
+        StorageType _queue;
+
+        //! Cancellation flag
+        volatile bool _canceled;
+
+        public:
+
+            //! Create a LockedQueue
+            LockedQueue() : _canceled(false) {}
+
+            //! Destroy a LockedQueue
+            virtual ~LockedQueue() { }
+
+            /**
+             * @see Queue::add(const T& item)
+             */
+            void add(const T& item)
+            {
+
+                ACE_Guard<LockType> g(_lock);
+
+                ASSERT(!_canceled);
+                //	throw Cancellation_Exception();
+
+                _queue.push_back(item);
+
+            }
+
+            /**
+             * @see Queue::next()
+             */
+            T next()
+            {
+
+                ACE_Guard<LockType> g(_lock);
+
+                ASSERT (!_queue.empty() || !_canceled);
+                //	throw Cancellation_Exception();
+
+                T item = _queue.front();
+                _queue.pop_front();
+
+                return item;
+
+            }
+
+            T front()
+            {
+                ACE_Guard<LockType> g(_lock);
+
+                ASSERT (!_queue.empty());
+                //	throw NoSuchElement_Exception();
+
+                return _queue.front();
+            }
+
+            /**
+             * @see Queue::cancel()
+             */
+            void cancel()
+            {
+
+                ACE_Guard<LockType> g(_lock);
+
+                _canceled = true;
+
+            }
+
+            /**
+             * @see Queue::isCanceled()
+             */
+            bool isCanceled()
+            {
+
+                // Faster check since the queue will not become un-canceled
+                if(_canceled)
+                    return true;
+
+                ACE_Guard<LockType> g(_lock);
+
+                return _canceled;
+
+            }
+
+            /**
+             * @see Queue::size()
+             */
+            size_t size()
+            {
+
+                ACE_Guard<LockType> g(_lock);
+                return _queue.size();
+
+            }
+
+            bool empty()
+            {
+
+                ACE_Guard<LockType> g(_lock);
+                return _queue.empty();
+            }
+
+    };
+
+}
+#endif
diff --git a/src/shared/Log.h b/src/shared/Log.h
index 654f3c0f04c..23555995020 100644
--- a/src/shared/Log.h
+++ b/src/shared/Log.h
@@ -82,7 +82,7 @@ enum ColorTypes
 
 const int Colors = int(WHITE)+1;
 
-class Log : public Trinity::Singleton<Log, Trinity::ClassLevelLockable<Log, ZThread::FastMutex> >
+class Log : public Trinity::Singleton<Log, Trinity::ClassLevelLockable<Log, ACE_Thread_Mutex> >
 {
     friend class Trinity::OperatorNew<Log>;
     Log();
diff --git a/src/shared/Makefile.am b/src/shared/Makefile.am
index 6b99351cb26..60af5b8a4b5 100644
--- a/src/shared/Makefile.am
+++ b/src/shared/Makefile.am
@@ -38,6 +38,7 @@ libmangosshared_a_SOURCES = \
 	Common.cpp \
 	Common.h \
 	Errors.h \
+	LockedQueue.h \
 	Log.cpp \
 	Log.h \
 	MemoryLeaks.cpp \
@@ -45,6 +46,8 @@ libmangosshared_a_SOURCES = \
 	ProgressBar.cpp \
 	ProgressBar.h \
 	Timer.h \
+	Threading.cpp \
+	Threading.h \
 	Util.cpp \
 	Util.h \
 	WorldPacket.h \
diff --git a/src/shared/MemoryLeaks.h b/src/shared/MemoryLeaks.h
index fcea1f557b1..c8b8fb8e1b1 100644
--- a/src/shared/MemoryLeaks.h
+++ b/src/shared/MemoryLeaks.h
@@ -31,9 +31,9 @@
 //#  include <stdlib.h>
 //#  include <crtdbg.h>
 #else
-#  define _CRTDBG_MAP_ALLOC
-#  include <stdlib.h>
-#  include <crtdbg.h>
+//#  define _CRTDBG_MAP_ALLOC
+//#  include <stdlib.h>
+//#  include <crtdbg.h>
 #endif
 
 #endif
diff --git a/src/shared/Threading.cpp b/src/shared/Threading.cpp
new file mode 100644
index 00000000000..496e86353ca
--- /dev/null
+++ b/src/shared/Threading.cpp
@@ -0,0 +1,205 @@
+/*
+ * Copyright (C) 2009 MaNGOS <http://getmangos.com/>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#include "Threading.h"
+#include <ace/OS_NS_unistd.h>
+#include <ace/Sched_Params.h>
+#include <vector>
+
+using namespace ACE_Based;
+
+ThreadPriority::ThreadPriority()
+{
+    for (int i = Idle; i < MAXPRIORITYNUM; ++i)
+        m_priority[i] = ACE_THR_PRI_OTHER_DEF;
+
+    m_priority[Idle] = ACE_Sched_Params::priority_min(ACE_SCHED_OTHER);
+    m_priority[Realtime] = ACE_Sched_Params::priority_max(ACE_SCHED_OTHER);
+
+    std::vector<int> _tmp;
+
+    ACE_Sched_Params::Policy _policy = ACE_SCHED_OTHER;
+    ACE_Sched_Priority_Iterator pr_iter(_policy);
+
+    while (pr_iter.more())
+    {
+        _tmp.push_back(pr_iter.priority());
+        pr_iter.next();
+    }
+
+    ASSERT (!_tmp.empty());
+
+    if(_tmp.size() >= MAXPRIORITYNUM)
+    {
+        const size_t max_pos = _tmp.size();
+        size_t min_pos = 1;
+        size_t norm_pos = 0;
+        for (size_t i = 0; i < max_pos; ++i)
+        {
+            if(_tmp[i] == ACE_THR_PRI_OTHER_DEF)
+            {
+                norm_pos = i + 1;
+                break;
+            }
+        }
+
+        //since we have only 7(seven) values in enum Priority
+        //and 3 we know already (Idle, Normal, Realtime) so
+        //we need to split each list [Idle...Normal] and [Normal...Realtime]
+        //into ¹ piesces
+        const size_t _divider = 4;
+        size_t _div = (norm_pos - min_pos) / _divider;
+        if(_div == 0)
+            _div = 1;
+
+        min_pos = (norm_pos - 1);
+
+        m_priority[Low] = _tmp[min_pos -= _div];
+        m_priority[Lowest] = _tmp[min_pos -= _div ];
+
+        _div = (max_pos - norm_pos) / _divider;
+        if(_div == 0)
+            _div = 1;
+
+        min_pos = norm_pos - 1;
+
+        m_priority[High] = _tmp[min_pos += _div];
+        m_priority[Highest] = _tmp[min_pos += _div];
+    }
+}
+
+int ThreadPriority::getPriority(Priority p) const
+{
+    if(p < Idle)
+        p = Idle;
+
+    if(p > Realtime)
+        p = Realtime;
+
+    return m_priority[p];
+}
+
+#define THREADFLAG (THR_NEW_LWP | THR_SCHED_DEFAULT| THR_JOINABLE)
+
+Thread::Thread() : m_task(0), m_iThreadId(0), m_hThreadHandle(0)
+{
+
+}
+
+Thread::Thread(Runnable& instance) : m_task(&instance), m_iThreadId(0), m_hThreadHandle(0)
+{
+    bool _start = start();
+    ASSERT (_start);
+}
+
+Thread::~Thread()
+{
+    //Wait();
+}
+
+//initialize Thread's class static member
+Thread::ThreadStorage Thread::m_ThreadStorage;
+ThreadPriority Thread::m_TpEnum;
+
+bool Thread::start()
+{
+    if(m_task == 0 || m_iThreadId != 0)
+        return false;
+
+    return (ACE_Thread::spawn(&Thread::ThreadTask, (void*)m_task, THREADFLAG, &m_iThreadId, &m_hThreadHandle) == 0);
+}
+
+bool Thread::wait()
+{
+    if(!m_hThreadHandle || !m_task)
+        return false;
+
+    ACE_THR_FUNC_RETURN _value = ACE_THR_FUNC_RETURN(-1);
+    int _res = ACE_Thread::join(m_hThreadHandle, &_value);
+
+    m_iThreadId = 0;
+    m_hThreadHandle = 0;
+
+    return (_res == 0);
+}
+
+void Thread::destroy()
+{
+    ACE_Thread::kill(m_iThreadId, -1);
+}
+
+void Thread::suspend()
+{
+    ACE_Thread::suspend(m_hThreadHandle);
+}
+
+void Thread::resume()
+{
+    ACE_Thread::resume(m_hThreadHandle);
+}
+
+ACE_THR_FUNC_RETURN Thread::ThreadTask(void * param)
+{
+    Runnable * _task = (Runnable*)param;
+    _task->run();
+
+    return (ACE_THR_FUNC_RETURN)0;
+}
+
+ACE_thread_t Thread::currentId()
+{
+    return ACE_Thread::self();
+}
+
+ACE_hthread_t Thread::currentHandle()
+{
+    ACE_hthread_t _handle;
+    ACE_Thread::self(_handle);
+
+    return _handle;
+}
+
+Thread * Thread::current()
+{
+    Thread * _thread = m_ThreadStorage.ts_object();
+    if(!_thread)
+    {
+        _thread = new Thread();
+        _thread->m_iThreadId = Thread::currentId();
+        _thread->m_hThreadHandle = Thread::currentHandle();
+
+        Thread * _oldValue = m_ThreadStorage.ts_object(_thread);
+        if(_oldValue)
+            delete _oldValue;
+    }
+
+    return _thread;
+}
+
+void Thread::setPriority(Priority type)
+{
+    int _priority = m_TpEnum.getPriority(type);
+    int _ok = ACE_Thread::setprio(m_hThreadHandle, _priority);
+    //remove this ASSERT in case you don't want to know is thread priority change was successful or not
+    ASSERT (_ok == 0);
+}
+
+void Thread::Sleep(unsigned long msecs)
+{
+    ACE_OS::sleep(ACE_Time_Value(0, 1000 * msecs));
+}
diff --git a/src/shared/Threading.h b/src/shared/Threading.h
new file mode 100644
index 00000000000..eac3c0e8efb
--- /dev/null
+++ b/src/shared/Threading.h
@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2009 MaNGOS <http://getmangos.com/>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+ */
+
+#ifndef THREADING_H
+#define THREADING_H
+
+#include <ace/Thread.h>
+#include <ace/TSS_T.h>
+#include <assert.h>
+#include "Errors.h"
+
+namespace ACE_Based
+{
+
+    class Runnable
+    {
+        public:
+            virtual ~Runnable() {}
+            virtual void run() = 0;
+    };
+
+    enum Priority
+    {
+        Idle,
+        Lowest,
+        Low,
+        Normal,
+        High,
+        Highest,
+        Realtime,
+    };
+
+#define MAXPRIORITYNUM (Realtime + 1)
+
+    class ThreadPriority
+    {
+        public:
+            ThreadPriority();
+            int getPriority(Priority p) const;
+
+        private:
+            int m_priority[MAXPRIORITYNUM];
+    };
+
+    class Thread
+    {
+        public:
+            Thread();
+            Thread(Runnable& instance);
+            ~Thread();
+
+            bool start();
+            bool wait();
+            void destroy();
+
+            void suspend();
+            void resume();
+
+            void setPriority(Priority type);
+
+            static void Sleep(unsigned long msecs);
+            static ACE_thread_t currentId();
+            static ACE_hthread_t currentHandle();
+            static Thread * current();
+
+        private:
+            Thread(const Thread&);
+            Thread& operator=(const Thread&);
+
+            static ACE_THR_FUNC_RETURN ThreadTask(void * param);
+
+            ACE_thread_t m_iThreadId;
+            ACE_hthread_t m_hThreadHandle;
+            Runnable * m_task;
+
+            typedef ACE_TSS<Thread> ThreadStorage;
+            //global object - container for Thread class representation of every thread
+            static ThreadStorage m_ThreadStorage;
+            //use this object to determine current OS thread priority values mapped to enum Priority{}
+            static ThreadPriority m_TpEnum;
+    };
+
+}
+#endif
diff --git a/src/shared/Util.cpp b/src/shared/Util.cpp
index 767b65e441c..ac57fc3c9e9 100644
--- a/src/shared/Util.cpp
+++ b/src/shared/Util.cpp
@@ -23,40 +23,34 @@
 #include "sockets/socket_include.h"
 #include "utf8cpp/utf8.h"
 #include "mersennetwister/MersenneTwister.h"
-#include "zthread/ThreadLocal.h"
+#include <ace/TSS_T.h>
 
-typedef ZThread::ThreadLocal<MTRand> MTRandTSS;
-
-/* NOTE: Not sure if static initialization is ok for TSS objects ,
- * as I see zthread uses custom implementation of the TSS
- * ,and in the consturctor there is no code ,so I suppose its ok
- * If its not ok ,change it to use singleton.
- */
+typedef ACE_TSS<MTRand> MTRandTSS;
 static MTRandTSS mtRand;
 
 int32 irand (int32 min, int32 max)
 {
-    return int32 (mtRand.get ().randInt (max - min)) + min;
+    return int32 (mtRand->randInt (max - min)) + min;
 }
 
 uint32 urand (uint32 min, uint32 max)
 {
-    return mtRand.get ().randInt (max - min) + min;
+    return mtRand->randInt (max - min) + min;
 }
 
 int32 rand32 ()
 {
-    return mtRand.get ().randInt ();
+    return mtRand->randInt ();
 }
 
 double rand_norm(void)
 {
-    return mtRand.get ().randExc ();
+    return mtRand->randExc ();
 }
 
 double rand_chance (void)
 {
-    return mtRand.get ().randExc (100.0);
+    return mtRand->randExc (100.0);
 }
 
 Tokens StrSplit(const std::string &src, const std::string &sep)