Una cola de bloqueo es una cola que admite tomar y poner.
La operación take toma un elemento de la cola. Si la cola está vacía, take se bloqueará hasta que haya elementos disponibles en la cola.
La operación de colocación coloca un elemento en la cola. Si la cola está llena, la colocación se bloqueará hasta que la cola tenga espacio libre.
Para implementar una cola de bloqueo simple, primero debemos tener un contenedor de muy bajo nivel, en cuanto a vector, deque o incluso list, no importa, elegimos deque como contenedor aquí.
La cola de bloqueo definida anteriormente está limitada, lo que significa que los elementos tienen un límite superior, por lo que habrá un bloqueo de elementos completo.
Comencemos con una cola de bloqueo simple e ilimitada, que puede almacenar elementos todo el tiempo de forma predeterminada. Por tanto, no tenemos que juzgar si la cola está llena de elementos. En este momento, solo necesitamos una variable de condición para determinar que la cola está vacía y bloqueada. El marco aproximado es el siguiente.
template<typename T>
class BlockQueue{
std::deque<T> que;
std::condition_variable empty;
std::mutex mtx; // declared for unique_lock;
public:
T take();
void put(T elem);
int size();
}
Entonces, ¿cómo realizar el core take and put?
En primer lugar, la operación de modificación de la cola debe estar bloqueada, cuando la programación concurrente implica modificar variables variables, debe bloquearse, lamentablemente tanto put como take modifican la cola.
Aquí use unique_lock para bloquear
std::unique_lock<std::mutex> lock{mtx};
De las dos operaciones, solo la operación take hará que la cola esté vacía, por lo que take debe determinar que la cola está vacía, y aquí se utilizan variables de condición
empty.wait(lock, [this]{return !que.empty();});
Así que salieron nuestras operaciones de compra y venta
template<typename T>
T BlockQueue::take(){
std::unique_lock<std::mutex> lock{mtx};
empty.wait(lock, [this]{return !que.empty();});
auto res = que.front():
que.pop_front():
return res;
}
template<typename T>
void BlockQueue::put(T elem){
std::unique_lock<std::mutex> lock{mtx};
que.push_back(T elem);
}
Autor: punto fijo
Enlace P : https: //www.jianshu.com/p/9dd1b7863667
Fuente: Los libros de Jane
tienen derechos de autor del autor. Para reimpresiones comerciales, comuníquese con el autor para obtener autorización. Para reimpresiones no comerciales, indique la fuente.