C++ 中的线程安全 ExpiringDeque 数据结构

Question

I am trying to create a data structure, ExpiringDeque. It should be somewhat similar to std::deque. Let's say I need only push_back(), size() and pop_front(). The data structure needs to automatically expire up to N first elements every T seconds.

This data structure needs to manage its own queue and expiration thread internally. How do I write it in a thread safe way? This is an example that I came up with, does this seem reasonable? What am I missing?

#include <algorithm>
#include <atomic>
#include <cassert>
#include <deque>
#include <mutex>
#include <thread>
#include <unistd.h>
#include <iostream>

template <typename T>
class ExpiringDeque {
 public:
  ExpiringDeque(int n, int t) : numElements_(n), interval_(t), running_(true), items_({}) {
    expiringThread_ = std::thread{[&] () {
      using namespace std::chrono_literals;
      int waitCounter = 0;
      while (true) {
        if (!running_) {
          return;
        }
        
        std::this_thread::sleep_for(1s);
        if (waitCounter++ < interval_) {
          continue;
        }
        
        std::lock_guard<std::mutex> guard(mutex_);
        waitCounter = 0;
        int numToErase = std::min(numElements_, static_cast<int>(items_.size()));
        std::cout << "Erasing " << numToErase << " elements\n";
        items_.erase(items_.begin(), items_.begin() + numToErase);
      }
    }};
  }

  ~ExpiringDeque() {
     running_ = false;
     expiringThread_.join();
   }

  T pop_front() {
    if (items_.size() == 0) {
      throw std::out_of_range("Empty deque");
    }
    std::lock_guard<std::mutex> guard(mutex_);
    T item = items_.front();
    items_.pop_front();
    return item;
  }
  
  int size() {
    std::lock_guard<std::mutex> guard(mutex_);
    return items_.size();
  }

  void push_back(T item) {
    std::lock_guard<std::mutex> guard(mutex_);
    items_.push_back(item);
  }

 private:
  int numElements_;
  int interval_;
  
  std::atomic<bool> running_;
  std::thread expiringThread_;

  std::mutex mutex_;
  std::deque<T> items_;
};

int main() {
    ExpiringDeque<int> ed(10, 3);
    ed.push_back(1);
    ed.push_back(2);
    ed.push_back(3);
    
    assert(ed.size() == 3);
    assert(ed.pop_front() == 1);
    assert(ed.size() == 2);
    
    // wait for expiration
    sleep(5);
    
    assert(ed.size() == 0);
    ed.push_back(10);
    assert(ed.size() == 1);
    assert(ed.pop_front() == 10);
    
    return 0;
}

Answer 1

You can avoid an unnecessary wait in the destructor of ExpiringDeque by using a condition variable. I would also use std::condition_variable::wait_for with a predicate to check the running_ flag. This will ensure that you either wait for a timeout or a notification, whichever is earlier. You avoid using waitCounter and continue this way.

Another thing you should do is lock the mutex before checking the size of your deque in pop_front() , otherwise it's not thread safe.

Here's an updated version of your code:

template <typename T>
class ExpiringDeque {
public:
    ExpiringDeque(int n, int t) : numElements_(n), interval_(t), running_(true), items_({}), cv_() {
        expiringThread_ = std::thread{ [&]() {
          using namespace std::chrono_literals;

          while (true) {
            //Wait for timeout or notification
            std::unique_lock<std::mutex> lk(mutex_);
            cv_.wait_for(lk, interval_ * 1s, [&] { return !running_; });

            if (!running_)
                return;

            //Mutex is locked already - no need to lock again
            int numToErase = std::min(numElements_, static_cast<int>(items_.size()));
            std::cout << "Erasing " << numToErase << " elements\n";
            items_.erase(items_.begin(), items_.begin() + numToErase);
          }
        } };
    }

    ~ExpiringDeque() {
        //Set flag and notify worker thread
        {
            std::lock_guard<std::mutex> lk(mutex_);
            running_ = false;
        }
        cv_.notify_one();
        expiringThread_.join();
    }

    T pop_front() {
        std::lock_guard<std::mutex> guard(mutex_);
        if (items_.size() == 0) {
            throw std::out_of_range("Empty deque");
        }
        T item = items_.front();
        items_.pop_front();
        return item;
    }

    ...

private:
    int numElements_;
    int interval_;

    bool running_;
    std::thread expiringThread_;

    std::mutex mutex_;
    std::deque<T> items_;
    std::condition_variable cv_;
};

You can make the running_ flag a normal bool since the std::condition_variable::wait_for atomically checks for the timeout or notification.