base/threading/worker_pool_posix.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4 //
   5 // The thread pool used in the POSIX implementation of WorkerPool dynamically
   6 // adds threads as necessary to handle all tasks.  It keeps old threads around
   7 // for a period of time to allow them to be reused.  After this waiting period,
   8 // the threads exit.  This thread pool uses non-joinable threads, therefore
   9 // worker threads are not joined during process shutdown.  This means that
  10 // potentially long running tasks (such as DNS lookup) do not block process
  11 // shutdown, but also means that process shutdown may "leak" objects.  Note that
  12 // although PosixDynamicThreadPool spawns the worker threads and manages the
  13 // task queue, it does not own the worker threads.  The worker threads ask the
  14 // PosixDynamicThreadPool for work and eventually clean themselves up.  The
  15 // worker threads all maintain scoped_refptrs to the PosixDynamicThreadPool
  16 // instance, which prevents PosixDynamicThreadPool from disappearing before all
  17 // worker threads exit.  The owner of PosixDynamicThreadPool should likewise
  18 // maintain a scoped_refptr to the PosixDynamicThreadPool instance.
  19 //
  20 // NOTE: The classes defined in this file are only meant for use by the POSIX
  21 // implementation of WorkerPool.  No one else should be using these classes.
  22 // These symbols are exported in a header purely for testing purposes.
  23
  24 #ifndef BASE_THREADING_WORKER_POOL_POSIX_H_
  25 #define BASE_THREADING_WORKER_POOL_POSIX_H_
  26
  27 #include <queue>
  28 #include <string>
  29
  30 #include "base/basictypes.h"
  31 #include "base/callback_forward.h"
  32 #include "base/location.h"
  33 #include "base/memory/ref_counted.h"
  34 #include "base/memory/scoped_ptr.h"
  35 #include "base/pending_task.h"
  36 #include "base/synchronization/condition_variable.h"
  37 #include "base/synchronization/lock.h"
  38 #include "base/threading/platform_thread.h"
  39 #include "base/tracked_objects.h"
  40
  41 class Task;
  42
  43 namespace base {
  44
  45 class BASE_EXPORT PosixDynamicThreadPool
  46     : public RefCountedThreadSafe<PosixDynamicThreadPool> {
  47  public:
  48   class PosixDynamicThreadPoolPeer;
  49
  50   // All worker threads will share the same |name_prefix|.  They will exit after
  51   // |idle_seconds_before_exit|.
  52   PosixDynamicThreadPool(const std::string& name_prefix,
  53                          int idle_seconds_before_exit);
  54
  55   // Indicates that the thread pool is going away.  Stops handing out tasks to
  56   // worker threads.  Wakes up all the idle threads to let them exit.
  57   void Terminate();
  58
  59   // Adds |task| to the thread pool.
  60   void PostTask(const tracked_objects::Location& from_here,
  61                 const Closure& task);
  62
  63   // Worker thread method to wait for up to |idle_seconds_before_exit| for more
  64   // work from the thread pool.  Returns NULL if no work is available.
  65   PendingTask WaitForTask();
  66
  67  private:
  68   friend class RefCountedThreadSafe<PosixDynamicThreadPool>;
  69   friend class PosixDynamicThreadPoolPeer;
  70
  71   ~PosixDynamicThreadPool();
  72
  73   // Adds pending_task to the thread pool.  This function will clear
  74   // |pending_task->task|.
  75   void AddTask(PendingTask* pending_task);
  76
  77   const std::string name_prefix_;
  78   const int idle_seconds_before_exit_;
  79
  80   Lock lock_;  // Protects all the variables below.
  81
  82   // Signal()s worker threads to let them know more tasks are available.
  83   // Also used for Broadcast()'ing to worker threads to let them know the pool
  84   // is being deleted and they can exit.
  85   ConditionVariable pending_tasks_available_cv_;
  86   int num_idle_threads_;
  87   TaskQueue pending_tasks_;
  88   bool terminated_;
  89   // Only used for tests to ensure correct thread ordering.  It will always be
  90   // NULL in non-test code.
  91   scoped_ptr<ConditionVariable> num_idle_threads_cv_;
  92
  93   DISALLOW_COPY_AND_ASSIGN(PosixDynamicThreadPool);
  94 };
  95
  96 }  // namespace base
  97
  98 #endif  // BASE_THREADING_WORKER_POOL_POSIX_H_