1 files changed, 72 insertions, 74 deletions

diff --git a/src/components/include/utils/threads/thread.h b/src/components/include/utils/threads/thread.h
index 3b81cf345..fd2b5e9fd 100644
--- a/src/components/include/utils/threads/thread.h
+++ b/src/components/include/utils/threads/thread.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2014, Ford Motor Company
+ * Copyright (c) 2015, Ford Motor Company
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -43,19 +43,19 @@
 #include "utils/macro.h"
 #include "utils/threads/thread_delegate.h"
 #include "utils/threads/thread_options.h"
+#include "utils/conditional_variable.h"
+#include "utils/lock.h"
 
 namespace threads {
 
-namespace impl {
 #if defined(OS_POSIX)
 typedef pthread_t PlatformThreadHandle;
 #else
 #error Please implement thread for your OS
 #endif
-}
 
 /**
- * Non platform specific thread abstraction that establishes a
+ * @brief Non platform specific thread abstraction that establishes a
  * threads::ThreadDelegate on a new thread.
  *
  * ThreadDelegate example:
@@ -75,60 +75,72 @@ typedef pthread_t PlatformThreadHandle;
  * thread.join();
  * printf("ok!\n");
  */
+
 class Thread;
+void enqueue_to_join(Thread* thread);
+
 Thread* CreateThread(const char* name, ThreadDelegate* delegate);
-void DeleteThread(Thread*);
+void DeleteThread(Thread* thread);
 
 class Thread {
-  friend Thread* CreateThread(const char*, ThreadDelegate*);
-  friend void DeleteThread(Thread*);
- public:
-  /**
-   * Class that represents unique in-process thread identifier
-   * due to restriction of pthread API it only allows checks
-   * for equality to different thread id and no ordering.
-   *
-   * ostream<< operator is provided for this class which
-   * outputs thread name associated to an identifier.
-   */
-  class Id {
-   public:
-    explicit Id(const impl::PlatformThreadHandle& id): id_(id) {}
-    bool operator==(const Id& that) const;
-    impl::PlatformThreadHandle Handle() const { return id_; }
-   private:
-    impl::PlatformThreadHandle id_;
-    friend class Thread;
-  };
-
-  // Get unique ID of currently executing thread
-  static Id CurrentId();
-
-  // Get name associated with thread identified by thread_id
-  static std::string NameFromId(const Id& thread_id);
-
-  // Give thread thread_id a name, helpful for debugging
-  static void SetNameForId(const Id& thread_id, const std::string& name);
+ private:
+  const std::string name_;
+  // Should be locked to protect delegate_ value
+  sync_primitives::Lock delegate_lock_;
+  ThreadDelegate* delegate_;
+  PlatformThreadHandle handle_;
+  ThreadOptions thread_options_;
+  // Should be locked to protect isThreadRunning_ and thread_created_ values
+  sync_primitives::Lock state_lock_;
+  volatile unsigned int isThreadRunning_;
+  volatile bool stopped_;
+  volatile bool finalized_;
+  bool thread_created_;
+  // Signalled when Thread::start() is called
+  sync_primitives::ConditionalVariable run_cond_;
 
+ public:
   /**
-   * Starts the thread.
+   * @brief Starts the thread.
    * @return true if the thread was successfully started.
    */
   bool start();
 
-  ThreadDelegate* delegate() const;
-
   /**
-   * Starts the thread. Behaves exactly like Start in addition to
+   * @brief Starts the thread. Behaves exactly like \ref start() in addition to
    * allow to override the default options.
-   * @param options - thread options. Look for 'threads/thread_options.h'
+   * @param options Thread options. Look for 'threads/thread_options.h'
    * for details.
    * @return true if the thread was successfully started.
    */
-  bool startWithOptions(const ThreadOptions& options);
+  bool start(const ThreadOptions& options);
+
+  sync_primitives::Lock& delegate_lock() {
+    return delegate_lock_;
+  }
+
+  ThreadDelegate *delegate() const {
+    return delegate_;
+  }
+
+  void set_delegate(ThreadDelegate *delegate) {
+    DCHECK(!isThreadRunning_);
+    delegate_ = delegate;
+  }
+
+  friend Thread* CreateThread(const char* name, ThreadDelegate* delegate);
+  friend void DeleteThread(Thread* thread);
+
+ public:
+  // Get unique ID of currently executing thread
+  static PlatformThreadHandle CurrentId();
+
+  // Give thread thread_id a name, helpful for debugging
+  static void SetNameForId(const PlatformThreadHandle& thread_id,
+                           std::string name);
 
   /**
-   * Signals the thread to exit and returns once the thread has exited.
+   * @brief Signals the thread to exit and returns once the thread has exited.
    * After this method returns, the Thread object is completely reset and may
    * be used as if it were newly constructed (i.e., Start may be called again).
    *
@@ -137,16 +149,18 @@ class Thread {
    */
   void stop();
 
+  void join();
+
   /**
-   * Get thread name.
+   * @brief Get thread name.
    * @return thread name
    */
-  const std::string& thread_name() {
+  const std::string& name() {
     return name_;
   }
 
   /**
-   * Returns true if the thread has been started, and not yet stopped.
+   * @brief Returns true if the thread has been started, and not yet stopped.
    * When a thread is running, the thread_id_ is non-zero.
    * @return true if the thread has been started, and not yet stopped.
    */
@@ -154,12 +168,10 @@ class Thread {
     return isThreadRunning_;
   }
 
-  void set_running(bool running) {
-    isThreadRunning_ = running;
-  }
+  void set_running(bool running);
 
   /**
-   * Is thread joinable?
+   * @brief Is thread joinable?
    * @return - Returns true if the thread is joinable.
    */
   bool is_joinable() const {
@@ -167,7 +179,7 @@ class Thread {
   }
 
   /**
-   * Thread stack size
+   * @brief Thread stack size
    * @return thread stack size
    */
   size_t stack_size() const {
@@ -175,23 +187,15 @@ class Thread {
   }
 
   /**
-   * The native thread handle.
+   * @brief The native thread handle.
    * @return thread handle.
    */
-  impl::PlatformThreadHandle thread_handle() const {
-    return thread_handle_;
-  }
-
-  /**
-   * Thread id.
-   * @return return thread id.
-   */
-  Id thread_id() const {
-    return Id(thread_handle());
+  PlatformThreadHandle thread_handle() const {
+    return handle_;
   }
 
   /**
-   * Thread options.
+   * @brief Thread options.
    * @return thread options.
    */
   const ThreadOptions& thread_options() const {
@@ -199,16 +203,12 @@ class Thread {
   }
 
   /**
-   * Minimum size of thread stack for specific platform.
+   * @brief Minimum size of thread stack for specific platform.
    */
   static size_t kMinStackSize;
 
  protected:
-  const std::string name_;
-  ThreadDelegate* delegate_;
-  impl::PlatformThreadHandle thread_handle_;
-  ThreadOptions thread_options_;
-  volatile unsigned int isThreadRunning_;
+  sync_primitives::ConditionalVariable state_cond_;
 
  private:
   /**
@@ -216,19 +216,17 @@ class Thread {
    * @param name - display string to identify the thread.
    * @param delegate - thread procedure delegate. Look for
    * 'threads/thread_delegate.h' for details.
-   * NOTE: delegate will be deleted by destructor.
+   * LifeCycle thread , otherwise it will be joined in stop method
+   * NOTE: delegate will be deleted after thread will be joined
    *       This constructor made private to prevent
    *       Thread object to be created on stack
    */
   Thread(const char* name, ThreadDelegate* delegate);
-
+  virtual ~Thread();
+  static void* threadFunc(void* arg);
+  static void cleanup(void* arg);
   DISALLOW_COPY_AND_ASSIGN(Thread);
-  virtual ~Thread() { }
 };
 
-inline bool operator!= (const Thread::Id& left, const Thread::Id& right) {
-  return !(left == right);
-}
-std::ostream& operator<<(std::ostream& os, const Thread::Id& thread_id);
 }  // namespace threads
 #endif  // SRC_COMPONENTS_INCLUDE_UTILS_THREADS_THREAD_H_