comparison thread/AsynchronousTask.h @ 69:6afa0e011f74

* Fix some locking problems

 
 #ifndef _ASYNCHRONOUS_TASK_H_
 #define _ASYNCHRONOUS_TASK_H_
 
 #include "Thread.h"
+
+#include <iostream>
 
 /**
  * AsynchronousTask provides a thread pattern implementation for
  * threads which are used to perform a series of similar operations in
  * parallel with other threads of the same type.

     {
         start();
     }
     virtual ~AsynchronousTask()
     {
+        m_todo.lock();
         m_finishing = true;
         m_todo.signal();
+        m_todo.unlock();
         wait();
     }
 
     // Subclass must provide methods to request task and obtain
     // results, which the caller calls.  The method that requests a

     // obtains results should call awaitTask() and then return any
     // results from internal state.
 
 protected:
     void startTask() {
+        m_done.lock();
         m_todo.lock();
         m_inTask = true;
         m_todo.signal();
-        m_done.lock();
         m_todo.unlock();
     }
     void awaitTask() {
-        m_done.lock();
-        while (m_inTask) m_done.wait();
+        m_done.wait();
         m_done.unlock();
     }
 
     virtual void performTask() = 0;
     
 private:
     virtual void run() {
         m_todo.lock();
-        while (!m_finishing) {
+        while (1) {
             while (!m_inTask && !m_finishing) {
                 m_todo.wait();
             }
             if (m_finishing) {
+                m_done.lock();
                 m_inTask = false;
                 m_done.signal();
+                m_done.unlock();
                 break;
             }
-            if (m_inTask) {
-                performTask();
-                m_inTask = false;
-                m_done.signal();
-            }
+            performTask();
+            m_done.lock();
+            m_inTask = false;
+            m_done.signal();
+            m_done.unlock();
         }
         m_todo.unlock();
     }
 
     Condition m_todo;