1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
// Copyright 2017 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef BASE_TASK_THREAD_POOL_POOLED_SINGLE_THREAD_TASK_RUNNER_MANAGER_H_
#define BASE_TASK_THREAD_POOL_POOLED_SINGLE_THREAD_TASK_RUNNER_MANAGER_H_
#include <memory>
#include <string>
#include <vector>
#include "base/base_export.h"
#include "base/memory/raw_ptr.h"
#include "base/task/common/checked_lock.h"
#include "base/task/single_thread_task_runner_thread_mode.h"
#include "base/task/thread_pool/environment_config.h"
#include "base/task/thread_pool/tracked_ref.h"
#include "base/thread_annotations.h"
#include "base/threading/platform_thread.h"
#include "build/build_config.h"
namespace base {
class TaskTraits;
class WorkerThreadObserver;
class SingleThreadTaskRunner;
namespace internal {
class DelayedTaskManager;
class WorkerThread;
class TaskTracker;
namespace {
class WorkerThreadDelegate;
} // namespace
// Manages a group of threads which are each associated with one or more
// SingleThreadTaskRunners.
//
// SingleThreadTaskRunners using SingleThreadTaskRunnerThreadMode::SHARED are
// backed by shared WorkerThreads for each COM+task environment combination.
// These workers are lazily instantiated and then only reclaimed during
// JoinForTesting()
//
// No threads are created (and hence no tasks can run) before Start() is called.
//
// This class is thread-safe.
class BASE_EXPORT PooledSingleThreadTaskRunnerManager final {
public:
PooledSingleThreadTaskRunnerManager(TrackedRef<TaskTracker> task_tracker,
DelayedTaskManager* delayed_task_manager);
PooledSingleThreadTaskRunnerManager(
const PooledSingleThreadTaskRunnerManager&) = delete;
PooledSingleThreadTaskRunnerManager& operator=(
const PooledSingleThreadTaskRunnerManager&) = delete;
~PooledSingleThreadTaskRunnerManager();
// Starts threads for existing SingleThreadTaskRunners and allows threads to
// be started when SingleThreadTaskRunners are created in the future.
// `io_thread_task_runner` is used to setup FileDescriptorWatcher on worker
// threads. `io_thread_task_runner` must refer to a Thread with
// MessgaePumpType::IO. If specified, |worker_thread_observer| will be
// notified when a worker enters and exits its main function. It must not be
// destroyed before JoinForTesting() has returned (must never be destroyed in
// production).
void Start(scoped_refptr<SingleThreadTaskRunner> io_thread_task_runner,
WorkerThreadObserver* worker_thread_observer = nullptr);
// Wakes up workers as appropriate for the new CanRunPolicy policy. Must be
// called after an update to CanRunPolicy in TaskTracker.
void DidUpdateCanRunPolicy();
// Creates a SingleThreadTaskRunner which runs tasks with |traits| on a thread
// named "ThreadPoolSingleThread[Shared]" +
// kEnvironmentParams[GetEnvironmentIndexForTraits(traits)].name_suffix +
// index.
scoped_refptr<SingleThreadTaskRunner> CreateSingleThreadTaskRunner(
const TaskTraits& traits,
SingleThreadTaskRunnerThreadMode thread_mode);
#if BUILDFLAG(IS_WIN)
// Creates a SingleThreadTaskRunner which runs tasks with |traits| on a COM
// STA thread named "ThreadPoolSingleThreadCOMSTA[Shared]" +
// kEnvironmentParams[GetEnvironmentIndexForTraits(traits)].name_suffix +
// index.
scoped_refptr<SingleThreadTaskRunner> CreateCOMSTATaskRunner(
const TaskTraits& traits,
SingleThreadTaskRunnerThreadMode thread_mode);
#endif // BUILDFLAG(IS_WIN)
void JoinForTesting();
private:
class PooledSingleThreadTaskRunner;
enum ContinueOnShutdown {
IS_CONTINUE_ON_SHUTDOWN,
IS_NOT_CONTINUE_ON_SHUTDOWN,
CONTINUE_ON_SHUTDOWN_COUNT,
};
static ContinueOnShutdown TraitsToContinueOnShutdown(
const TaskTraits& traits);
template <typename DelegateType>
scoped_refptr<PooledSingleThreadTaskRunner> CreateTaskRunnerImpl(
const TaskTraits& traits,
SingleThreadTaskRunnerThreadMode thread_mode);
template <typename DelegateType>
std::unique_ptr<WorkerThreadDelegate> CreateWorkerThreadDelegate(
const std::string& name,
int id,
SingleThreadTaskRunnerThreadMode thread_mode);
template <typename DelegateType>
WorkerThread* CreateAndRegisterWorkerThread(
const std::string& name,
SingleThreadTaskRunnerThreadMode thread_mode,
ThreadType thread_type_hint) EXCLUSIVE_LOCKS_REQUIRED(lock_);
template <typename DelegateType>
WorkerThread*& GetSharedWorkerThreadForTraits(const TaskTraits& traits);
void UnregisterWorkerThread(WorkerThread* worker);
void ReleaseSharedWorkerThreads();
const TrackedRef<TaskTracker> task_tracker_;
const raw_ptr<DelayedTaskManager> delayed_task_manager_;
scoped_refptr<SingleThreadTaskRunner> io_thread_task_runner_;
// Optional observer notified when a worker enters and exits its main
// function. Set in Start() and never modified afterwards.
raw_ptr<WorkerThreadObserver> worker_thread_observer_ = nullptr;
CheckedLock lock_;
std::vector<scoped_refptr<WorkerThread>> workers_ GUARDED_BY(lock_);
int next_worker_id_ GUARDED_BY(lock_) = 0;
// Workers for SingleThreadTaskRunnerThreadMode::SHARED tasks. It is
// important to have separate threads for CONTINUE_ON_SHUTDOWN and non-
// CONTINUE_ON_SHUTDOWN to avoid being in a situation where a
// CONTINUE_ON_SHUTDOWN task effectively blocks shutdown by preventing a
// BLOCK_SHUTDOWN task to be scheduled. https://crbug.com/829786
WorkerThread* shared_worker_threads_[ENVIRONMENT_COUNT]
[CONTINUE_ON_SHUTDOWN_COUNT] GUARDED_BY(
lock_) = {};
#if BUILDFLAG(IS_WIN)
WorkerThread* shared_com_worker_threads_
[ENVIRONMENT_COUNT][CONTINUE_ON_SHUTDOWN_COUNT] GUARDED_BY(lock_) = {};
#endif // BUILDFLAG(IS_WIN)
// Set to true when Start() is called.
bool started_ GUARDED_BY(lock_) = false;
};
} // namespace internal
} // namespace base
#endif // BASE_TASK_THREAD_POOL_POOLED_SINGLE_THREAD_TASK_RUNNER_MANAGER_H_
|
