+threading

20 files changed, 681 insertions, 12 deletions

diff --git a/source/libs/asura-lib-utils/io/binding/_io_task.cpp b/source/libs/asura-lib-utils/io/binding/_io_task.cpp
new file mode 100644
index 0000000..c03ff2a
--- /dev/null
+++ b/source/libs/asura-lib-utils/io/binding/_io_task.cpp
@@ -0,0 +1,36 @@
+#include "../io_task.h"
+
+using namespace std;
+
+namespace AsuraEngine 
+{
+	namespace IO 
+	{
+		
+		LUAX_REGISTRY(IOTask)
+		{
+			LUAX_REGISTER_METHODS(state,
+				{ "New", _New }
+			);
+		}
+
+		LUAX_POSTPROCESS(IOTask)
+		{
+
+		}
+
+		// task = IOTask.New(path, dst)
+		LUAX_IMPL_METHOD(IOTask, _New)
+		{
+			LUAX_STATE(L);
+
+			cc8* path = state.CheckParam<cc8*>(1);
+			DataBuffer* db = state.CheckUserdata<DataBuffer>(2);
+			IOTask* task = new IOTask(path, db);
+			task->PushLuaxUserdata(state);
+			task->SetLuaxMemberRef(state, task->mDstRef, 2);
+			return 1;
+		}
+
+	}
+}
diff --git a/source/libs/asura-lib-utils/io/data_buffer.cpp b/source/libs/asura-lib-utils/io/data_buffer.cpp
index 3c0100b..000869d 100644
--- a/source/libs/asura-lib-utils/io/data_buffer.cpp
+++ b/source/libs/asura-lib-utils/io/data_buffer.cpp
@@ -2,6 +2,8 @@
 #include <cstring>
 #include "data_buffer.h"
 
+using namespace AEThreading;
+
 namespace AsuraEngine
 {
 	namespace IO
@@ -16,6 +18,7 @@ namespace AsuraEngine
 			: mSize(size)
 			, mBytes(nullptr)
 		{
+			lock(mMutex);
 			mBytes = new byte[size];
 			memset(mBytes, 0, size);
 		}
@@ -34,6 +37,7 @@ namespace AsuraEngine
 
 		void DataBuffer::Refactor(size_t size)
 		{
+			lock(mMutex);
 			if (!mBytes || mSize != size)
 			{
 				delete[] mBytes;
@@ -50,6 +54,7 @@ namespace AsuraEngine
 
 		size_t DataBuffer::Load(const void* data, std::size_t size)
 		{
+			lock(mMutex);
 			size_t len = mSize > size ? size : mSize;
 			memcpy(mBytes, data, len);
 			return len;
@@ -57,6 +62,7 @@ namespace AsuraEngine
 
 		void DataBuffer::Move(void* bytes, std::size_t size)
 		{
+			lock(mMutex);
 			if (!mBytes)
 			{
 				delete[] mBytes;
@@ -72,10 +78,11 @@ namespace AsuraEngine
 
 		void DataBuffer::Clear()
 		{
+			lock(mMutex);
 			if (mBytes)
 				memset(mBytes, 0, mSize);
 		}
-
+		
 		std::size_t DataBuffer::GetSize()
 		{
 			return mSize;
diff --git a/source/libs/asura-lib-utils/io/data_buffer.h b/source/libs/asura-lib-utils/io/data_buffer.h
index c63a248..9dfe541 100644
--- a/source/libs/asura-lib-utils/io/data_buffer.h
+++ b/source/libs/asura-lib-utils/io/data_buffer.h
@@ -4,6 +4,7 @@
 #include <cstdlib>
 
 #include "../scripting/portable.hpp"
+#include "../threading/mutex.h"
 
 namespace AsuraEngine
 {
@@ -39,6 +40,8 @@ namespace AsuraEngine
 			byte* mBytes;
 			size_t mSize;
 
+			AEThreading::Mutex mMutex;
+
 			LUAX_DECL_METHOD(_New);
 			LUAX_DECL_METHOD(_GetData);
 			LUAX_DECL_METHOD(_GetSize);
diff --git a/source/libs/asura-lib-utils/io/file.h b/source/libs/asura-lib-utils/io/file.h
index 4a6d38b..56077e0 100644
--- a/source/libs/asura-lib-utils/io/file.h
+++ b/source/libs/asura-lib-utils/io/file.h
@@ -4,6 +4,7 @@
 #include "physfs/physfs.h"
 
 #include "../scripting/portable.hpp"
+#include "../threading/thread.h"
 
 #include "file_data.h"
 
@@ -58,6 +59,7 @@ namespace AsuraEngine
 			///
 			size_t Read(ASURA_OUT DataBuffer* dst, size_t length);
 			size_t ReadAll(ASURA_OUT DataBuffer* dst);
+			size_t ReadAsync(ASURA_OUT DataBuffer* dst);
 
 			///
 			/// �Ƿ�������ļ���β
@@ -70,6 +72,11 @@ namespace AsuraEngine
 			bool Write(ASURA_REF DataBuffer* src);
 
 			///
+			/// �첽д�ļ�����д�ļ�task����thread�Ķ��С�
+			///
+			bool WriteAsync(ASURA_REF DataBuffer* src, AEThreading::Thread* thread);
+
+			///
 			/// ��������˻��壬ǿ����ջ�������д���ļ���
 			///
 			bool Flush();
@@ -118,8 +125,10 @@ namespace AsuraEngine
 			LUAX_DECL_METHOD(_GetMode);
 			LUAX_DECL_METHOD(_GetSize);
 			LUAX_DECL_METHOD(_Read);
-			LUAX_DECL_METHOD(_IsEOF);
 			LUAX_DECL_METHOD(_Write);
+			LUAX_DECL_METHOD(_ReadAsync);
+			LUAX_DECL_METHOD(_WriteAsync);
+			LUAX_DECL_METHOD(_IsEOF);
 			LUAX_DECL_METHOD(_Flush);
 			LUAX_DECL_METHOD(_Tell);
 			LUAX_DECL_METHOD(_Seek);
diff --git a/source/libs/asura-lib-utils/io/io_task.cpp b/source/libs/asura-lib-utils/io/io_task.cpp
index e69de29..a96c293 100644
--- a/source/libs/asura-lib-utils/io/io_task.cpp
+++ b/source/libs/asura-lib-utils/io/io_task.cpp
@@ -0,0 +1,29 @@
+#include "io_task.h"
+
+namespace AsuraEngine
+{
+	namespace IO
+	{
+
+		IOTask::IOTask(const std::string& path, DataBuffer* buffer)
+			: mPath(path)
+			, mDst(buffer)
+		{
+		}
+
+		IOTask::~IOTask()
+		{
+		}
+
+		bool IOTask::Execute()
+		{
+			return true;
+		}
+
+		void IOTask::Invoke()
+		{
+
+		}
+
+	}
+}
diff --git a/source/libs/asura-lib-utils/io/io_task.h b/source/libs/asura-lib-utils/io/io_task.h
index b91a88c..aa5b38e 100644
--- a/source/libs/asura-lib-utils/io/io_task.h
+++ b/source/libs/asura-lib-utils/io/io_task.h
@@ -16,7 +16,7 @@ namespace AsuraEngine
 		///
 		/// ��ȡ�ļ�����
 		///
-		class IOTask
+		class IOTask ASURA_FINAL
 			: public AEScripting::Portable<IOTask>
 			, public AEThreading::ThreadTask
 		{
@@ -24,13 +24,21 @@ namespace AsuraEngine
 
 			LUAX_DECL_FACTORY(IOTask);
 
+			IOTask(const std::string& path, DataBuffer* buffer);
+			~IOTask();
+
 			bool Execute() override ;
+			void Invoke() override;
 
 		private:
 
 			std::string mPath; 
 			DataBuffer* mDst;
 
+			Luax::LuaxMemberRef mDstRef;
+
+			LUAX_DECL_METHOD(_New);
+
 		};
 
 	}
diff --git a/source/libs/asura-lib-utils/math/quaternion.cpp b/source/libs/asura-lib-utils/math/quaternion.cpp
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/source/libs/asura-lib-utils/math/quaternion.cpp
diff --git a/source/libs/asura-lib-utils/math/quaternion.h b/source/libs/asura-lib-utils/math/quaternion.h
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/source/libs/asura-lib-utils/math/quaternion.h
diff --git a/source/libs/asura-lib-utils/threading/binding/_coroutine.cpp b/source/libs/asura-lib-utils/threading/binding/_coroutine.cpp
new file mode 100644
index 0000000..7f74cca
--- /dev/null
+++ b/source/libs/asura-lib-utils/threading/binding/_coroutine.cpp
@@ -0,0 +1,40 @@
+#include "../coroutine.h"
+
+using namespace std;
+
+namespace AsuraEngine 
+{
+	namespace Threading 
+	{
+		
+		LUAX_REGISTRY(Coroutine)
+		{
+			LUAX_REGISTER_METHODS(state,
+				{ "New", _New },
+				{ "Run", _Run }
+			);
+		}
+
+		LUAX_POSTPROCESS(Coroutine)
+		{
+
+		}
+
+		// Coroutine.New()
+		LUAX_IMPL_METHOD(Coroutine, _New)
+		{
+			LUAX_STATE(L);
+
+			return 0;
+		}
+
+		// coroutine:Run()
+		LUAX_IMPL_METHOD(Coroutine, _Run)
+		{
+			LUAX_PREPARE(L, Coroutine);
+
+			return 0;
+		}
+
+	}
+}
diff --git a/source/libs/asura-lib-utils/threading/binding/_thread.cpp b/source/libs/asura-lib-utils/threading/binding/_thread.cpp
new file mode 100644
index 0000000..9f6d228
--- /dev/null
+++ b/source/libs/asura-lib-utils/threading/binding/_thread.cpp
@@ -0,0 +1,104 @@
+#include "../thread.h"
+
+using namespace std;
+
+namespace AsuraEngine 
+{
+	namespace Threading 
+	{
+		
+		LUAX_REGISTRY(Thread)
+		{
+			LUAX_REGISTER_METHODS(state,
+				{ "New",       _New       },
+				{ "Start",     _Start     },
+				{ "Join",      _Join      },
+				{ "Kill",      _Kill      },
+				{ "AddTask",   _AddTask   },
+				{ "IsRunning", _IsRunning },
+				{ "IsCurrent", _IsCurrent },
+				{ "GetName",   _GetName   }
+			);
+		}
+
+		LUAX_POSTPROCESS(Thread)
+		{
+
+		}
+
+		// thread = Thread.New(name)
+		LUAX_IMPL_METHOD(Thread, _New)
+		{
+			LUAX_STATE(L);
+
+			cc8* name = state.GetValue<cc8*>(1, "");
+
+			Thread* thread = new Thread(name); 
+			thread->PushLuaxUserdata(state);
+
+			return 1;
+		}
+
+		// thread:Start()
+		LUAX_IMPL_METHOD(Thread, _Start)
+		{
+			LUAX_PREPARE(L, Thread);
+			self->Start();
+			return 0;
+		}
+
+		// thread:Join()
+		LUAX_IMPL_METHOD(Thread, _Join)
+		{
+			LUAX_PREPARE(L, Thread);
+			self->Join();
+			return 0;
+		}
+
+		// thread:Kill()
+		LUAX_IMPL_METHOD(Thread, _Kill)
+		{
+			LUAX_PREPARE(L, Thread);
+			self->Kill();
+			return 0;
+		}
+
+		// successed = thread:AddTask(thread_task)
+		LUAX_IMPL_METHOD(Thread, _AddTask)
+		{
+			LUAX_PREPARE(L, Thread);
+
+			ThreadTask* task = state.GetUserdata<ThreadTask>(2);
+			self->AddTask(task);
+			self->LuaxRetain<ThreadTask>(state, task);
+			return 0;
+		}
+
+		// thread:IsRunning()
+		LUAX_IMPL_METHOD(Thread, _IsRunning)
+		{
+			LUAX_PREPARE(L, Thread);
+
+			state.Push(self->IsRunning());
+			return 0;
+		}
+
+		// thread:IsCurrent()
+		LUAX_IMPL_METHOD(Thread, _IsCurrent)
+		{
+			LUAX_PREPARE(L, Thread);
+
+			state.Push(self->IsCurrent());
+			return 0;
+		}
+
+		// thread:GetName()
+		LUAX_IMPL_METHOD(Thread, _GetName)
+		{
+			LUAX_PREPARE(L, Thread);
+			
+			return 0;
+		}
+
+	}
+}
diff --git a/source/libs/asura-lib-utils/threading/coroutine.h b/source/libs/asura-lib-utils/threading/coroutine.h
index 1ac6b21..75d9a10 100644
--- a/source/libs/asura-lib-utils/threading/coroutine.h
+++ b/source/libs/asura-lib-utils/threading/coroutine.h
@@ -28,4 +28,6 @@ namespace AsuraEngine
 	}
 }
 
+namespace AEThreading = AsuraEngine::Threading;
+
 #endif
\ No newline at end of file
diff --git a/source/libs/asura-lib-utils/threading/mutex.cpp b/source/libs/asura-lib-utils/threading/mutex.cpp
index e69de29..e0b6e1e 100644
--- a/source/libs/asura-lib-utils/threading/mutex.cpp
+++ b/source/libs/asura-lib-utils/threading/mutex.cpp
@@ -0,0 +1,81 @@
+#include <asura-lib-utils/exceptions/exception.h>
+
+#include "mutex.h"
+
+namespace AsuraEngine
+{
+	namespace Threading
+	{
+
+#define try_create_mutex(impl)\
+	if (!mImpl)						  \
+	{											  \
+		try									  \
+		{										  \
+			mImpl = new impl(); \
+		}										  \
+		catch (Exception& e)  \
+		{										  \
+			mImpl = nullptr;	  \
+		}										  \
+	}											 
+
+		Mutex::Mutex()
+			: mImpl(nullptr)
+		{
+#if ASURA_THREAD_WIN32 
+			try_create_mutex(MutexImplWin32);
+#endif
+			ASSERT(mImpl);
+		}
+
+		Mutex::~Mutex()
+		{
+			delete mImpl;
+		}
+
+		void Mutex::Lock()
+		{
+			ASSERT(mImpl);
+
+			mImpl->Lock();
+		}
+
+		void Mutex::Unlock()
+		{
+			ASSERT(mImpl);
+
+			mImpl->Unlock();
+		}
+
+#if ASURA_THREAD_WIN32 
+		MutexImplWin32::MutexImplWin32()
+		{
+			//mHandle = ::CreateMutex(NULL, FALSE, NULL);
+			//if (!mHandle)
+			//	throw Exception("Cant use win32 mutex.");
+			::InitializeCriticalSection(&mMutex);
+		}
+
+		MutexImplWin32::~MutexImplWin32()
+		{
+			//::CloseHandle(mHandle);
+			//mHandle = NULL;
+			::DeleteCriticalSection(&mMutex);
+		}
+
+		void MutexImplWin32::Lock() 
+		{
+			//::WaitForSingleObject(mHandle, INFINITE);
+			::EnterCriticalSection(&mMutex);
+		}
+
+		void MutexImplWin32::Unlock()
+		{
+			//::ReleaseMutex(mHandle);
+			::LeaveCriticalSection(&mMutex);
+		}
+#endif // ASURA_THREAD_WIN32
+
+	}
+}
diff --git a/source/libs/asura-lib-utils/threading/mutex.h b/source/libs/asura-lib-utils/threading/mutex.h
index 893c6e5..5ed45ae 100644
--- a/source/libs/asura-lib-utils/threading/mutex.h
+++ b/source/libs/asura-lib-utils/threading/mutex.h
@@ -1,21 +1,105 @@
 #ifndef __ASURA_MUTEX_H__
 #define __ASURA_MUTEX_H__
 
+#include <asura-lib-utils/type.h>
+
+#include "../utils_config.h"
+
+#if ASURA_THREAD_WIN32
+	#include <windows.h>
+#endif
+
 namespace AsuraEngine
 {
 	namespace Threading
 	{
 
+		class MutexImpl;
+
 		class Mutex
 		{
 		public:
 
+			Mutex();
+			~Mutex();
+
 			void Lock();
 			void Unlock();
 
+		private:
+
+			MutexImpl* mImpl;
+
+		};
+
+		class Lock
+		{
+		public:
+			Lock(Mutex& mutex)
+				: m(mutex)
+			{
+				m.Lock();
+			};
+			~Lock()
+			{
+				m.Unlock();
+			}
+		private: 
+			void* operator new(size_t);
+			Mutex& m;
+		};
+
+#define lock(mutex) Lock _asura_scoped_lock_0x0_(mutex)
+#define lock2(mutex) Lock _asura_scoped_lock_0x1_(mutex)
+#define lock3(mutex) Lock _asura_scoped_lock_0x2_(mutex)
+#define lock4(mutex) Lock _asura_scoped_lock_0x3_(mutex)
+#define lock5(mutex) Lock _asura_scoped_lock_0x4_(mutex)
+
+		ASURA_ABSTRACT class MutexImpl
+		{
+		public:
+
+			MutexImpl() {};
+			virtual ~MutexImpl() {};
+
+			virtual void Lock() = 0; 
+			virtual void Unlock() = 0;
+
+		};
+
+#if ASURA_THREAD_WIN32 
+
+		//https://blog.csdn.net/l799623787/article/details/18259949
+		class MutexImplWin32 ASURA_FINAL : public MutexImpl
+		{
+		public:
+
+			MutexImplWin32(); 
+			~MutexImplWin32();
+
+			void Lock() override;
+			void Unlock() override;
+
+		private: 
+
+			//HANDLE mHandle;
+			CRITICAL_SECTION mMutex;
+
 		};
 
+#endif // ASURA_THREAD_WIN32 
+
+#if ASURA_THREAD_STD 
+
+		class MutexImplSTD ASURA_FINAL : public MutexImpl
+		{
+		};
+
+#endif // ASURA_THREAD_STD 
+
 	}
 }
 
+namespace AEThreading = AsuraEngine::Threading;
+
 #endif
\ No newline at end of file
diff --git a/source/libs/asura-lib-utils/threading/thread.cpp b/source/libs/asura-lib-utils/threading/thread.cpp
index c77f3ab..d1b055d 100644
--- a/source/libs/asura-lib-utils/threading/thread.cpp
+++ b/source/libs/asura-lib-utils/threading/thread.cpp
@@ -1,13 +1,92 @@
 #include "thread.h"
 
+#include "thread_impl_win32.h"
+#include "thread_impl_posix.h"
+#include "thread_impl_sdl.h"
+#include "thread_impl_std.h"
+
 namespace AsuraEngine
 {
 	namespace Threading
 	{
 
-		bool Thread::Enqueue(ThreadTask* task)
+		Thread::Thread(const std::string& name)
+			: mName(name)
+		{
+		}
+
+		Thread::~Thread()
+		{
+			delete mImpl;
+		}
+
+#define try_start_thread(impl)\
+	if (!mImpl) \
+	{ \
+		mImpl = new impl(); \
+		if (!mImpl->Start(this, stacksize)) \
+		{ \
+			delete mImpl; \
+			mImpl = nullptr; \
+		} \
+	}
+
+		bool Thread::AddTask(ThreadTask* task)
+		{
+			mTaskQueue.push(task);
+			return true;
+		}
+
+		void Thread::Start(uint32 stacksize)
+		{
+#if ASURA_THREAD_WIN32
+			try_start_thread(ThreadImplWin32);
+#endif
+
+			assert(mImpl);
+		}
+
+		void Thread::Join()
+		{
+			assert(mImpl); 
+			mImpl->Join();
+		}
+
+		void Thread::Kill()
+		{
+			assert(mImpl);
+			mImpl->Kill(); 
+		}
+
+		bool Thread::IsRunning()
+		{
+			assert(mImpl);
+			return mImpl->IsRunning(); 
+		}
+
+		bool Thread::IsCurrent()
+		{
+			assert(mImpl);
+			return mImpl->IsCurrent(); 
+		}
+
+		const std::string& Thread::GetName()
+		{
+			return mName;
+		}
+
+		void Thread::Execute()
 		{
+			while (!mTaskQueue.empty())
+			{
+				ThreadTask* task = mTaskQueue.front();
+				if (task->Execute())
+					task->Invoke();
 
+				mMutex.Lock();
+				mTaskQueue.pop();
+				mMutex.Unlock();
+			}
 		}
 
 	}
diff --git a/source/libs/asura-lib-utils/threading/thread.h b/source/libs/asura-lib-utils/threading/thread.h
index 0058144..24b549c 100644
--- a/source/libs/asura-lib-utils/threading/thread.h
+++ b/source/libs/asura-lib-utils/threading/thread.h
@@ -1,10 +1,13 @@
 #ifndef __ASURA_THREAD_H__
 #define __ASURA_THREAD_H__
 
+#include <string>
 #include <queue>
+
 #include <asura-lib-utils/scripting/portable.hpp>
 
 #include "thread_task.h"
+#include "mutex.h"
 
 namespace AsuraEngine
 {
@@ -23,21 +26,55 @@ namespace AsuraEngine
 
 			LUAX_DECL_FACTORY(Thread);
 
-			bool Enqueue(ThreadTask* task);
+			Thread(const std::string& name = "");
+			~Thread();
+
+			bool AddTask(ThreadTask* task);
+
+			void Start(uint32 stacksize = 0);
+
+			///
+			/// ǿ����ֹ�̡߳�ע��Ҫ������new��delete֮��ִ��TerminateThread��������򽫲����ڼ���ʹ��new�ˡ�
+			/// https://blog.csdn.net/anye3000/article/details/7470674
+			///
+			void Kill();
+
+			///
+			/// ���̵߳ȴ����߳̽�����ż���ִ�С�
+			///
+			void Join();
+
+			bool IsRunning();
 
-			void Run();
+			bool IsCurrent();
+
+			///
+			/// ִ��������С�
+			///
+			void Execute();
+
+			const std::string& GetName();
 
 		private:
 
+			LUAX_DECL_METHOD(_New);
+			LUAX_DECL_METHOD(_Start);
+			LUAX_DECL_METHOD(_Join);
+			LUAX_DECL_METHOD(_Kill);
+			LUAX_DECL_METHOD(_AddTask);
+			LUAX_DECL_METHOD(_IsRunning);
+			LUAX_DECL_METHOD(_IsCurrent);
+			LUAX_DECL_METHOD(_GetName);
+
 			///
-			/// �������
+			/// ���������������
 			///
 			std::queue<ThreadTask*> mTaskQueue;
 
-			ThreadImpl* mImpl;
+			Mutex mMutex;
 
-			LUAX_DECL_METHOD(_Enqueue);
-			LUAX_DECL_METHOD(_Run);
+			ThreadImpl* mImpl;
+			std::string mName;
 
 		};
 
@@ -51,6 +88,15 @@ namespace AsuraEngine
 		ASURA_ABSTRACT class ThreadImpl
 		{
 		public:
+			ThreadImpl() {};
+			virtual ~ThreadImpl() {};
+
+			virtual bool Start(Thread* thread, uint32 stacksize = 0) = 0;
+			virtual void Join() = 0;
+			virtual void Kill() = 0;
+
+			virtual bool IsRunning() = 0;
+			virtual bool IsCurrent() = 0;
 
 		};
 
diff --git a/source/libs/asura-lib-utils/threading/thread_impl_std.h b/source/libs/asura-lib-utils/threading/thread_impl_std.h
index e69de29..0e7d3da 100644
--- a/source/libs/asura-lib-utils/threading/thread_impl_std.h
+++ b/source/libs/asura-lib-utils/threading/thread_impl_std.h
@@ -0,0 +1,43 @@
+#ifndef __ASURA_THREAD_STD_H__
+#define __ASURA_THREAD_STD_H__
+
+#include "../utils_config.h"
+
+#if ASURA_THREAD_STD
+
+#include <windows.h>
+
+#include "thread.h"
+
+namespace AsuraEngine
+{
+	namespace Threading
+	{
+
+		///
+		/// Thread��std::threadʵ�֡�
+		///
+		class ThreadImplSTD : public ThreadImpl
+		{
+		public:
+
+			ThreadImplSTD();
+			~ThreadImplSTD();
+
+			bool Start(Thread* thread, uint32 stacksize) override;
+			void Join() override;
+			void Kill() override;
+
+			bool IsRunning() override;
+			bool IsCurrent() override;
+
+		private:
+
+		};
+
+	}
+}
+
+#endif // #if ASURA_THREAD_STD
+
+#endif // __ASURA_THREAD_STD_H__
\ No newline at end of file
diff --git a/source/libs/asura-lib-utils/threading/thread_impl_win32.cpp b/source/libs/asura-lib-utils/threading/thread_impl_win32.cpp
index e69de29..fd1b066 100644
--- a/source/libs/asura-lib-utils/threading/thread_impl_win32.cpp
+++ b/source/libs/asura-lib-utils/threading/thread_impl_win32.cpp
@@ -0,0 +1,69 @@
+#include "thread_impl_win32.h"
+#include "thread.h"
+
+namespace AsuraEngine
+{
+	namespace Threading
+	{
+
+		static DWORD WINAPI _thread_win32_runner(LPVOID param)
+		{
+			Thread* thread = (Thread*)param;
+			thread->Execute();
+			return 0;
+		}
+
+		ThreadImplWin32::ThreadImplWin32()
+		{
+		}
+
+		ThreadImplWin32::~ThreadImplWin32()
+		{
+			if (!mHandle) return;
+			::CloseHandle(mHandle);
+			mHandle = 0;
+		}
+
+		bool ThreadImplWin32::Start(Thread* thread, uint32 stacksize/*=0*/)
+		{
+			assert(!IsRunning());
+			mHandle = ::CreateThread(
+				NULL
+				, stacksize
+				, _thread_win32_runner
+				, thread
+				, 0 /*���������������*/
+			  , NULL);
+
+			return mHandle;
+		}
+
+		void ThreadImplWin32::Join()
+		{
+			// ���̵߳ȴ����̷߳���
+			::WaitForSingleObject(mHandle, INFINITE);
+		}
+
+		void ThreadImplWin32::Kill()
+		{
+			::TerminateThread(mHandle, FALSE);
+		}
+
+		bool ThreadImplWin32::IsRunning()
+		{
+			if (mHandle) {
+				DWORD exitCode = 0;
+				// https://blog.csdn.net/yuanmeng567/article/details/19485719
+				::GetExitCodeThread(mHandle, &exitCode);
+				return exitCode == STILL_ACTIVE;
+			}
+			return false;
+		}
+
+		bool ThreadImplWin32::IsCurrent()
+		{
+			return mHandle == ::GetCurrentThread();
+		}
+
+	}
+}
\ No newline at end of file
diff --git a/source/libs/asura-lib-utils/threading/thread_impl_win32.h b/source/libs/asura-lib-utils/threading/thread_impl_win32.h
index 3dd2a8e..361152f 100644
--- a/source/libs/asura-lib-utils/threading/thread_impl_win32.h
+++ b/source/libs/asura-lib-utils/threading/thread_impl_win32.h
@@ -6,6 +6,7 @@
 #if ASURA_THREAD_WIN32
 
 #include <windows.h>
+
 #include "thread.h"
 
 namespace AsuraEngine
@@ -20,6 +21,16 @@ namespace AsuraEngine
 		{
 		public:
 
+			ThreadImplWin32();
+			~ThreadImplWin32();
+
+			bool Start(Thread* thread, uint32 stacksize) override;
+			void Join() override;
+
+			void Kill() override;
+
+			bool IsRunning() override;
+			bool IsCurrent() override;
 
 		private:
 
@@ -32,4 +43,4 @@ namespace AsuraEngine
 
 #endif // #if ASURA_THREAD_WIN32
 
-#endif
\ No newline at end of file
+#endif // __ASURA_THREAD_WIN32_H__
\ No newline at end of file
diff --git a/source/libs/asura-lib-utils/threading/thread_task.h b/source/libs/asura-lib-utils/threading/thread_task.h
index 35e159c..1ea0a1a 100644
--- a/source/libs/asura-lib-utils/threading/thread_task.h
+++ b/source/libs/asura-lib-utils/threading/thread_task.h
@@ -2,6 +2,7 @@
 #define __ASURA_THRAD_TASK_H__
 
 #include <asura-lib-utils/type.h>
+#include <asura-lib-utils/scripting/portable.hpp>
 
 namespace AsuraEngine
 {
@@ -11,12 +12,28 @@ namespace AsuraEngine
 		///
 		/// ϣ��������һ���̴߳��������񣬼̳�Task����дExecute������
 		///
-		ASURA_ABSTRACT class ThreadTask
+		ASURA_ABSTRACT class ThreadTask 
+			: virtual public AEScripting::NativeAccessor
 		{
 		public:
 
+			ThreadTask(); 
+			virtual ~ThreadTask();
+
+			///
+			/// ִ��������ɺ󷵻�true�����ûص�������
+			///
 			virtual bool Execute() = 0;
 
+			///
+			/// ���ûص���
+			///
+			virtual void Invoke() = 0;
+
+		protected: 
+
+			Luax::LuaxMemberRef mCallback;
+
 		};
 
 	}
diff --git a/source/libs/asura-lib-utils/utils_config.h b/source/libs/asura-lib-utils/utils_config.h
index 836eb07..d5208d5 100644
--- a/source/libs/asura-lib-utils/utils_config.h
+++ b/source/libs/asura-lib-utils/utils_config.h
@@ -2,5 +2,6 @@
 #define __ASURA_UTILS_CONFIG_H__
 
 #define ASURA_THREAD_WIN32 1
+#define ASURA_THREAD_STD 1
 
 #endif
\ No newline at end of file