2 files changed, 468 insertions, 0 deletions

diff --git a/src/libjin/multithread/je_thread.cpp b/src/libjin/multithread/je_thread.cpp
new file mode 100644
index 0000000..0c528bf
--- /dev/null
+++ b/src/libjin/multithread/je_thread.cpp
@@ -0,0 +1,301 @@
+#include "../core/je_configuration.h"
+#if defined(jin_thread)
+
+#include "je_thread.h"
+
+namespace JinEngine
+{
+	namespace MultiThread
+	{
+
+		class Mutex
+		{
+		public:
+			Mutex();
+			~Mutex();
+
+			void lock();
+			void unlock();
+		private:
+		#if jin_thread == jin_thread_sdl
+			SDL_mutex* mutex;
+		#endif 
+			friend class Conditional;
+		};
+
+		// ���������̼߳�signal wait
+		class Conditional
+		{
+		public:
+			Conditional();
+			~Conditional();
+			void signal();
+			void broadcast();
+			bool wait(Mutex* mutex, int timeout = -1);
+		private:
+		#if jin_thread == jin_thread_sdl
+			SDL_cond* cond;
+		#endif
+		};
+
+		class Lock
+		{
+		public:
+			Lock(Mutex* m) : mutex(m) {
+				mutex->lock();
+			}
+
+			Lock(Mutex& m) : mutex(&m) {
+				mutex->lock();
+			}
+
+			~Lock() {
+				mutex->unlock();
+			}
+		private:
+			Mutex* mutex;
+
+			Lock(Lock&) {}
+
+		};
+
+		//////////////////////////////////////////////////////////////////////
+    
+		Mutex::Mutex()
+		{
+		#if jin_thread == jin_thread_sdl
+			mutex = SDL_CreateMutex();
+		#endif
+		}
+
+		Mutex::~Mutex()
+		{
+		#if jin_thread == jin_thread_sdl
+			SDL_DestroyMutex(mutex);
+		#endif
+		}
+
+		void Mutex::lock()
+		{
+		#if jin_thread == jin_thread_sdl
+			SDL_LockMutex(mutex);
+		#endif
+		}
+
+		void Mutex::unlock()
+		{
+		#if jin_thread == jin_thread_sdl
+			SDL_UnlockMutex(mutex);
+		#endif
+		}
+
+		//////////////////////////////////////////////////////////////////////
+
+		Conditional::Conditional()
+		{
+		#if jin_thread == jin_thread_sdl
+			cond = SDL_CreateCond();
+		#endif
+		}
+
+		Conditional::~Conditional()
+		{
+		#if jin_thread == jin_thread_sdl
+			SDL_DestroyCond(cond);
+		#endif
+		}
+
+		void Conditional::signal()
+		{
+		#if jin_thread == jin_thread_sdl
+			SDL_CondSignal(cond);
+		#endif
+		}
+
+		void Conditional::broadcast()
+		{
+		#if jin_thread == jin_thread_sdl
+			SDL_CondBroadcast(cond);
+		#endif
+		}
+
+		bool Conditional::wait(Mutex* mutex, int timeout)
+		{
+		#if jin_thread == jin_thread_sdl
+			if (timeout < 0)
+				return !SDL_CondWait(cond, mutex->mutex);
+			else
+				return (SDL_CondWaitTimeout(cond, mutex->mutex, timeout) == 0);
+		#endif
+		}
+    
+		//////////////////////////////////////////////////////////////////////
+
+		Thread::ThreadData::ThreadData(Mutex* m, Conditional* c)
+			: mutex(m)
+			, condition(c)
+			, share()
+		{
+		}
+
+		Thread::ThreadData::~ThreadData()
+		{
+		}
+
+		void Thread::ThreadData::set(int slot, Variant value)
+		{
+			Lock l(mutex);
+			share[slot] = value;
+		}
+
+		Thread::Variant Thread::ThreadData::get(int slot)
+		{
+			Lock l(mutex);
+			return share[slot];
+		}
+
+		bool Thread::ThreadData::exist(int slot)
+		{
+			Lock l(mutex);
+			return share.count(slot) == 1;
+		}
+
+		void Thread::ThreadData::remove(int slot)
+		{
+			Lock l(mutex);
+			if (exist(slot))
+			{
+				share.erase(slot);
+			}
+		}
+
+		//////////////////////////////////////////////////////////////////////
+
+		Thread::Thread(const std::string tname, ThreadRunner runner)
+			: name(tname)
+			, running(false)
+			, threadRunner(runner)
+		{
+			mutex = new Mutex();
+			condition = new Conditional();
+			common = new Thread::ThreadData(mutex, condition);
+		}
+
+		Thread::~Thread()
+		{
+		#if jin_thread == jin_thread_sdl
+		#endif
+		}
+
+		const char* Thread::getName()
+		{
+			Lock l(mutex);
+			return name.c_str();
+		};
+    
+		bool Thread::isRunning()
+		{
+			Lock l(mutex);
+			return running;
+		};
+
+		bool Thread::start(void* p)
+		{
+			Lock l(mutex);
+			if (running) 
+				return false;
+			if (handle)
+			{
+			#if jin_thread == jin_thread_sdl
+				SDL_WaitThread(handle, nullptr);
+			#endif
+			}
+		#if jin_thread == jin_thread_sdl
+			handle = SDL_CreateThread(threadRunner, name.c_str(), p);
+		#elif jin_thread == jin_thread_cpp
+			handle = new std::thread();
+		#endif 
+			return (running = (handle != nullptr));
+		}
+
+		void Thread::wait()
+		{
+			{
+				Lock l(mutex);
+				if (!handle)
+					return;
+			}
+		#if jin_thread == jin_thread_sdl
+			SDL_WaitThread(handle, nullptr);
+		#endif
+			Lock l(mutex);
+			running = false; 
+			handle = nullptr;
+		}
+
+		void Thread::lock()
+		{
+			if (mutex != nullptr)
+				mutex->lock();
+		}
+
+		void Thread::unlock()
+		{
+			if (mutex != nullptr)
+				mutex->unlock();
+		}
+
+		void Thread::send(int slot, const Variant& value)
+		{
+			lock(); 
+			common->set(slot, value);
+			unlock();
+			condition->broadcast();
+		}
+
+		bool Thread::receive(int slot)
+		{
+			return common->exist(slot);
+		}
+
+		Thread::Variant Thread::fetch(int slot)
+		{
+			Thread::Variant v = common->get(slot);
+			return v;
+		}
+
+		Thread::Variant Thread::demand(int slot)
+		{
+			/**
+			 * pthread_mutex_lock(mtx);
+			 * while(pass == 0) 
+			 * {
+			 *     pthread_mutex_unlock(mtx);
+			 *     pthread_cond_just_wait(cv);
+			 *     pthread_mutex_lock(mtx);
+			 * }
+			 * pthread_mutex_unlock(mtx);
+			 */
+			lock();
+			while (!common->exist(slot))
+			{
+				if (common->exist(ThreadData::SLOT_ERROR))
+					return 0;
+				condition->wait(mutex);
+			}
+			Thread::Variant v = common->get(slot);
+			unlock();
+			return v;
+		}
+
+		void Thread::remove(int slot)
+		{
+			lock(); 
+			common->remove(slot);
+			unlock();
+		}
+
+	} // namespace MultiThread
+} // namespace JinEngine
+
+#endif // defined(jin_thread)
\ No newline at end of file
diff --git a/src/libjin/multithread/je_thread.h b/src/libjin/multithread/je_thread.h
new file mode 100644
index 0000000..353690c
--- /dev/null
+++ b/src/libjin/multithread/je_thread.h
@@ -0,0 +1,167 @@
+#ifndef __JE_THREAD_H
+#define __JE_THREAD_H
+#include "../core/je_configuration.h"
+#if defined(jin_thread)
+
+#include <string>
+#include <map>
+#if jin_thread == jin_thread_sdl 
+    #include "SDL2/SDL_thread.h"
+#elif jin_thread == jin_thread_cpp 
+    #include <thread>
+    #include <mutex>
+    #include <condition_variable>
+#endif
+
+namespace JinEngine
+{
+	namespace MultiThread
+	{
+		/**
+		 * ��������Ӣ�Ӣ�Mutual exclusion����д Mutex����һ�����ڶ��̱߳���У���ֹ�����߳�ͬʱ��ͬһ������Դ
+		 * ����ȫ�ֱ��������ж�д�Ļ��ơ���Ŀ��ͨ����������Ƭ��һ��һ�����ٽ�����critical section����ɡ��ٽ�����
+		 * ָ����һ��Թ�����Դ���з��ʵĴ��룬����һ�ֻ��ƻ����㷨��һ�����򡢽��̡��߳̿���ӵ�ж���ٽ����򣬵��Dz�
+		 * ��һ����Ӧ�û���������Ҫ�˻��Ƶ���Դ�������У���ꡢ���С����������жϴ�������������ڶ����������еĴ����
+		 * �������ݡ�ͬ��״̬�ȵ���Դ��ά����Щ��Դ��ͬ����һ�º������Ǻ����ѵģ���Ϊһ���߳̿������κ�һ��ʱ�̱���ͣ
+		 * ���ߣ����߻ָ������ѣ���
+		 */
+		class Mutex;
+		class Conditional;
+
+		//
+		// Thread::demand	Receive a message from a thread. Wait for the message to exist before returning.	
+		// Thread::getName  Get the name of a thread.	
+		// Thread::kill	    Forcefully terminate the thread.	
+		// Thread::peek	    Receive a message from a thread, but leave it in the message box.	
+		// Thread::receive  Receive a message from a thread.	
+		// Thread::send	    Send a message.	
+		// Thread::set	    Set a value.	
+		// Thread::start	Starts the thread.	
+		// Thread::wait	    Wait for a thread to finish.
+		//
+		class Thread
+		{
+		public:
+			struct Variant
+			{
+				enum Type
+				{
+					NONE = 0,
+					INTERGER, 
+					BOOLEAN, 
+					CHARACTER, 
+					CSTRING, 
+					POINTER, 
+					REAL,
+				};
+				Type type;
+				union 
+				{
+					int integer;
+					bool boolean;
+					char character;
+					const char* cstring;
+					void* pointer;
+					float real;
+				};
+				Variant() :type(NONE) {};
+				Variant(const Variant& v){ memcpy(this, &v, sizeof(v)); }
+				Variant(int i) : integer(i), type(INTERGER) {};
+				Variant(float f) : real(f), type(REAL) {};
+				Variant(bool b) : boolean(b), type(BOOLEAN) {};
+				Variant(char c) : character(c), type(CHARACTER) {};
+				Variant(const char* s) : cstring(s), type(CSTRING) {};
+				Variant(void* p) : pointer(p), type(POINTER) {};
+			};
+
+		private:
+			class ThreadData
+			{
+			public:
+				static const int SLOT_ERROR = -1;
+				static const int SLOT_WARN = -2;
+				static const int SLOT_INFO = -3;
+				static const int SLOT_DEBUG = -4;
+
+				ThreadData(Mutex*, Conditional*);
+				~ThreadData();
+				bool exist(int slot);
+				void set(int slot, Variant value);
+				Variant get(int slot);
+				void remove(int slot);
+
+				Conditional* condition;
+				Mutex* mutex;
+
+			private:
+				std::map<int, Variant> share; // threads shared value
+
+			};
+
+		public:
+			typedef int(*ThreadRunner)(void* obj);
+
+			Thread(const std::string name, ThreadRunner threadfuncs);
+			~Thread();
+			bool start(void* p);
+			void wait();
+			void send(int slot, const Variant& value);
+			bool receive(int slot);
+			Variant fetch(int slot);
+			Variant demand(int slot);
+			void remove(int slot);
+			const char* getName();
+			bool isRunning();
+			void lock();
+			void unlock();
+
+		protected:
+		#if jin_thread == jin_thread_sdl 
+			SDL_Thread* handle;         // SDL thread
+		#elif jin_thread == jin_thread_cpp 
+			std::thread* handle;        // cpp thread
+		#endif
+			Mutex* mutex;               // mutex variable
+			Conditional* condition;     // condition variable
+			ThreadRunner threadRunner; // thread function 
+			ThreadData* common;         // threads common data
+			const std::string name;     // thread name, for debugging purposes 
+			/**
+			 * https://stackoverflow.com/questions/149932/naming-conventions-for-threads
+			 *
+			 * Use short names because they don't make the lines in a log file too long.
+			 * 
+			 * Create names where the important part is at the beginning. Log viewers in a 
+			 * graphical user interface tend to have tables with columns, and the thread 
+			 * column is usually small or will be made small by you to read everything else.
+			 * 
+			 * Do not use the word "thread" in the thread name because it is obvious.
+			 * 
+			 * Make the thread names easily grep-able. Avoid similar sounding thread names
+			 * 
+			 * If you have several threads of the same nature, enumerate them with IDs that 
+			 * are unique to one execution of the application or one log file, whichever fits 
+			 * your logging habits.
+			 * 
+			 * Avoid generalizations like "WorkerThread" (how do you name the next 5 worker 
+			 * threads?), "GUIThread" (which GUI? is it for one window? for everything?) or 
+			 * "Calculation" (what does it calculate?).
+			 * 
+			 * If you have a test group that uses thread names to grep your application's log 
+			 * files, do not rename your threads after some time. Your testers will hate you for 
+			 * doing so. Thread names in well-tested applications should be there to stay.
+			 * 
+			 * When you have threads that service a network connection, try to include the target 
+			 * network address in the thread name (e.g. channel_123.212.123.3). Don't forget about 
+			 * enumeration though if there are multiple connections to the same host.
+			 */
+			bool running;               // running
+
+		};
+
+	} // namespace MultiThread
+} // namespace JinEngine
+
+#endif // defined(jin_thread)
+
+#endif // __JE_THREAD_H
\ No newline at end of file