diff --git a/base/TaskRunner.cpp b/base/TaskRunner.cpp
index 2f7d89c..33117e7 100644
--- a/base/TaskRunner.cpp
+++ b/base/TaskRunner.cpp
@@ -19,30 +19,31 @@
 
 namespace android {
 namespace hardware {
+namespace details {
 
 TaskRunner::TaskRunner() {
-    bool *running = mRunning = new bool();
-    SynchronizedQueue<std::function<void(void)>> *q
-            = mQueue = new SynchronizedQueue<std::function<void(void)>>();
-    mThread = new std::thread([running, q] {
-        *running = true;
-        while (*running) {
-            (q->wait_pop())();
-        }
-        delete q;
-        delete running;
-    });
-}
-TaskRunner::~TaskRunner() {
-    bool *running = mRunning;
-    std::thread *t = mThread;
-    mThread->detach();
-    mQueue->push([running, t] {
-        *running = false;
-        delete t;
-    });
 }
 
+void TaskRunner::start(size_t limit) {
+    mQueue = std::make_shared<SynchronizedQueue<Task>>(limit);
+
+    // Allow the thread to continue running in background;
+    // TaskRunner do not care about the std::thread object.
+    std::thread{[q = mQueue] {
+        Task nextTask;
+        while (!!(nextTask = q->wait_pop())) {
+            nextTask();
+        }
+    }}.detach();
+}
+
+TaskRunner::~TaskRunner() {
+    if (mQueue) {
+        mQueue->push(nullptr);
+    }
+}
+
+} // namespace details
 } // namespace hardware
 } // namespace android
 
diff --git a/base/include/hidl/SynchronizedQueue.h b/base/include/hidl/SynchronizedQueue.h
index 80123ba..efb04e0 100644
--- a/base/include/hidl/SynchronizedQueue.h
+++ b/base/include/hidl/SynchronizedQueue.h
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ANDROID_SYNCHRONIZED_QUEUE_H
-#define ANDROID_SYNCHRONIZED_QUEUE_H
+#ifndef ANDROID_HIDL_SYNCHRONIZED_QUEUE_H
+#define ANDROID_HIDL_SYNCHRONIZED_QUEUE_H
 
 #include <condition_variable>
 #include <mutex>
@@ -24,10 +24,12 @@
 
 namespace android {
 namespace hardware {
+namespace details {
 /* Threadsafe queue.
  */
 template <typename T>
 struct SynchronizedQueue {
+    SynchronizedQueue(size_t limit);
 
     /* Gets an item from the front of the queue.
      *
@@ -43,19 +45,18 @@
      */
     size_t size();
 
-    /* Sets the limit to the queue. Will fail
-     * the push operation if the limit is reached.
-     */
-    void setLimit(size_t limit);
-
 private:
     std::condition_variable mCondition;
     std::mutex mMutex;
     std::queue<T> mQueue;
-    size_t mQueueLimit = SIZE_MAX;
+    const size_t mQueueLimit;
 };
 
 template <typename T>
+SynchronizedQueue<T>::SynchronizedQueue(size_t limit) : mQueueLimit(limit) {
+}
+
+template <typename T>
 T SynchronizedQueue<T>::wait_pop() {
     std::unique_lock<std::mutex> lock(mMutex);
 
@@ -93,14 +94,8 @@
     return mQueue.size();
 }
 
-template <typename T>
-void SynchronizedQueue<T>::setLimit(size_t limit) {
-    std::unique_lock<std::mutex> lock(mMutex);
-
-    mQueueLimit = limit;
-}
-
+} // namespace details
 } // namespace hardware
 } // namespace android
 
-#endif
+#endif // ANDROID_HIDL_SYNCHRONIZED_QUEUE_H
diff --git a/base/include/hidl/TaskRunner.h b/base/include/hidl/TaskRunner.h
index bc9087f..8ecceca 100644
--- a/base/include/hidl/TaskRunner.h
+++ b/base/include/hidl/TaskRunner.h
@@ -13,56 +13,55 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-#ifndef ANDROID_TASK_RUNNER_H
-#define ANDROID_TASK_RUNNER_H
+#ifndef ANDROID_HIDL_TASK_RUNNER_H
+#define ANDROID_HIDL_TASK_RUNNER_H
 
 #include "SynchronizedQueue.h"
+#include <memory>
 #include <thread>
 
 namespace android {
 namespace hardware {
+namespace details {
 
 /*
  * A background infinite loop that runs the Tasks push()'ed.
- * Just a simple single-threaded thread pool.
+ * Equivalent to a simple single-threaded Looper.
  */
 class TaskRunner {
 public:
+    using Task = std::function<void(void)>;
 
-    /* Kicks off the loop immediately. */
+    /* Create an empty task runner. Nothing will be done until start() is called. */
     TaskRunner();
 
     /*
-     * Detaches the background thread and return immediately.
-     * Tasks in the queue will continue to be done sequentially, and _after_
-     * all tasks are done, the background thread releases the resources
-     * (the queue, the std::thread object, etc.)
+     * Notify the background thread to terminate and return immediately.
+     * Tasks in the queue will continue to be done sequentially in background
+     * until all tasks are finished.
      */
     ~TaskRunner();
 
     /*
-     * Add a task. Return true if successful, false if
-     * the queue's size exceeds limit.
+     * Sets the queue limit. Fails the push operation once the limit is reached.
+     * Then kicks off the loop.
      */
-    inline bool push(const std::function<void(void)> &t) {
-        return this->mQueue->push(t);
-    }
+    void start(size_t limit);
 
     /*
-     * Sets the queue limit. Fails the push operation once the limit is reached.
+     * Add a task. Return true if successful, false if
+     * the queue's size exceeds limit or t doesn't contain a callable target.
      */
-    inline void setLimit(size_t limit) {
-        this->mQueue->setLimit(limit);
+    inline bool push(const Task &t) {
+        return (mQueue != nullptr) && (!!t) && this->mQueue->push(t);
     }
-private:
 
-    // resources managed by the background thread.
-    bool *mRunning;
-    SynchronizedQueue<std::function<void(void)>> *mQueue;
-    std::thread *mThread;
+private:
+    std::shared_ptr<SynchronizedQueue<Task>> mQueue;
 };
 
+} // namespace details
 } // namespace hardware
 } // namespace android
 
-#endif // ANDROID_TASK_RUNNER_H
+#endif // ANDROID_HIDL_TASK_RUNNER_H
diff --git a/test_main.cpp b/test_main.cpp
index 7ff8ae3..7859156 100644
--- a/test_main.cpp
+++ b/test_main.cpp
@@ -255,8 +255,9 @@
 }
 
 TEST_F(LibHidlTest, TaskRunnerTest) {
-    using android::hardware::TaskRunner;
+    using android::hardware::details::TaskRunner;
     TaskRunner tr;
+    tr.start(1 /* limit */);
     bool flag = false;
     tr.push([&] {
         usleep(1000);