*update

1 files changed, 46 insertions, 21 deletions

diff --git a/src/libjin/Thread/Thread.cpp b/src/libjin/Thread/Thread.cpp
index 06975f7..374778b 100644
--- a/src/libjin/Thread/Thread.cpp
+++ b/src/libjin/Thread/Thread.cpp
@@ -23,6 +23,7 @@ namespace thread
         friend class Conditional;
     };
 
+    // ���������̼߳�signal wait
     class Conditional
     {
     public:
@@ -43,15 +44,19 @@ namespace thread
         Lock(Mutex* m) : mutex(m) {
             mutex->lock();
         }
+
         Lock(Mutex& m) : mutex(&m) {
             mutex->lock();
         }
+
         ~Lock() {
             mutex->unlock();
         }
     private:
         Mutex* mutex;
+
         Lock(Lock&) {}
+
     };
 
     //////////////////////////////////////////////////////////////////////
@@ -137,33 +142,43 @@ namespace thread
     {
     }
 
-    void Thread::ThreadData::set(std::string name, Value value)
+    void Thread::ThreadData::set(int slot, Variant value)
     {
-        //if (share.count(name) != 0);
-        share[name] = value;
+        Lock l(mutex);
+        share[slot] = value;
     }
 
-    Thread::Value Thread::ThreadData::get(std::string name)
+    Thread::Variant Thread::ThreadData::get(int slot)
     {
-        return share[name];
+        Lock l(mutex);
+        return share[slot];
     }
 
-    bool Thread::ThreadData::exist(const std::string& name)
+    bool Thread::ThreadData::exist(int slot)
     {
-        return share.count(name) == 1;
+        Lock l(mutex);
+        return share.count(slot) == 1;
     }
 
-    void Thread::ThreadData::remove(std::string name)
+    void Thread::ThreadData::remove(int slot)
     {
         Lock l(mutex);
-        if (exist(name))
+        if (exist(slot))
         {
-            share.erase(name);
+            share.erase(slot);
         }
     }
 
     //////////////////////////////////////////////////////////////////////
 
+    int Thread::ThreadFunciton(void* p)
+    {
+        Thread* thread = (Thread*)p;
+        if (thread->threadRunner != nullptr)
+            thread->threadRunner(thread);
+        return 0;
+    }
+
     Thread::Thread(const std::string tname, ThreadRunner runner)
         : name(tname)
         , running(false)
@@ -204,7 +219,7 @@ namespace thread
         #endif
         }
     #if JIN_THREAD_SDL
-        handle = SDL_CreateThread(threadRunner, name.c_str(), this);
+        handle = SDL_CreateThread(ThreadFunciton, name.c_str(), this);
     #elif JIN_THREAD_CPP 
         handle = new std::thread();
     #endif 
@@ -238,35 +253,45 @@ namespace thread
             mutex->unlock();
     }
 
-    void Thread::send(std::string name, Value value)
+    void Thread::send(int slot, Variant value)
     {
         lock(); 
-        common->set(name, value);
+        common->set(slot, value);
         unlock();
         condition->broadcast();
     }
 
-    bool Thread::receive(std::string name)
+    bool Thread::receive(int slot)
     {
-        return common->exist(name);
+        return common->exist(slot);
     }
 
-    Thread::Value Thread::fetch(std::string name)
+    Thread::Variant Thread::fetch(int slot)
     {
-        Thread::Value v = common->get(name);
+        Thread::Variant v = common->get(slot);
         return v;
     }
 
-    Thread::Value Thread::demand(std::string name)
+    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(name))
+        while (!common->exist(slot))
         {
-            if (common->exist("error"))
+            if (common->exist(ThreadData::SLOT_ERROR))
                 return 0;
             condition->wait(mutex);
         }
-        Thread::Value v = common->get(name);
+        Thread::Variant v = common->get(slot);
         unlock();
         return v;
     }