blob: f848c82c423cab6c7b74f0ddd3f9a9a4b9a5e243 (
plain)
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
|
/*
* Copyright (C) 2019 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#pragma once
#include <condition_variable>
#include <functional>
#include <list>
#include <mutex>
#include <optional>
#include "android-base/thread_annotations.h"
namespace android {
/**
* A thread-safe FIFO queue. This list-backed queue stores up to <i>capacity</i> objects if
* a capacity is provided at construction, and is otherwise unbounded.
* Objects can always be added. Objects are added immediately.
* If the queue is full, new objects cannot be added.
*
* The action of retrieving an object will block until an element is available.
*/
template <class T>
class BlockingQueue {
public:
explicit BlockingQueue() = default;
explicit BlockingQueue(size_t capacity) : mCapacity(capacity){};
/**
* Retrieve and remove the oldest object.
* Blocks execution indefinitely while queue is empty.
*/
T pop() {
std::unique_lock lock(mLock);
android::base::ScopedLockAssertion assumeLock(mLock);
mHasElements.wait(lock, [this]() REQUIRES(mLock) { return !this->mQueue.empty(); });
T t = std::move(mQueue.front());
mQueue.erase(mQueue.begin());
return t;
};
/**
* Retrieve and remove the oldest object.
* Blocks execution for the given duration while queue is empty, and returns std::nullopt
* if the queue was empty for the entire duration.
*/
std::optional<T> popWithTimeout(std::chrono::nanoseconds duration) {
std::unique_lock lock(mLock);
android::base::ScopedLockAssertion assumeLock(mLock);
if (!mHasElements.wait_for(lock, duration,
[this]() REQUIRES(mLock) { return !this->mQueue.empty(); })) {
return {};
}
T t = std::move(mQueue.front());
mQueue.erase(mQueue.begin());
return t;
};
/**
* Add a new object to the queue.
* Does not block.
* Return true if an element was successfully added.
* Return false if the queue is full.
*/
bool push(T&& t) {
{ // acquire lock
std::scoped_lock lock(mLock);
if (mCapacity && mQueue.size() == mCapacity) {
return false;
}
mQueue.push_back(std::move(t));
} // release lock
mHasElements.notify_one();
return true;
};
/**
* Construct a new object into the queue.
* Does not block.
* Return true if an element was successfully added.
* Return false if the queue is full.
*/
template <class... Args>
bool emplace(Args&&... args) {
{ // acquire lock
std::scoped_lock lock(mLock);
if (mCapacity && mQueue.size() == mCapacity) {
return false;
}
mQueue.emplace_back(args...);
} // release lock
mHasElements.notify_one();
return true;
};
void erase_if(const std::function<bool(const T&)>& pred) {
std::scoped_lock lock(mLock);
std::erase_if(mQueue, pred);
}
/**
* Remove all elements.
* Does not block.
*/
void clear() {
std::scoped_lock lock(mLock);
mQueue.clear();
};
/**
* How many elements are currently stored in the queue.
* Primary used for debugging.
* Does not block.
*/
size_t size() {
std::scoped_lock lock(mLock);
return mQueue.size();
}
private:
const std::optional<size_t> mCapacity;
/**
* Used to signal that mQueue is non-empty.
*/
std::condition_variable mHasElements;
/**
* Lock for accessing and waiting on elements.
*/
std::mutex mLock;
std::list<T> mQueue GUARDED_BY(mLock);
};
} // namespace android
|
