Line data    Source code

       1             : /******************************************************************************
       2             :  *
       3             :  * Project:  CPL
       4             :  * Purpose:  Implementation of a thread-safe queue
       5             :  * Author:   Even Rouault <even dot rouault at spatialys.com>
       6             :  *
       7             :  ******************************************************************************
       8             :  * Copyright (c) 2022, Even Rouault <even dot rouault at spatialys.com>
       9             :  *
      10             :  * SPDX-License-Identifier: MIT
      11             :  ****************************************************************************/
      12             : 
      13             : #ifndef CPL_THREADSAFE_QUEUE_INCLUDED
      14             : #define CPL_THREADSAFE_QUEUE_INCLUDED
      15             : 
      16             : #include <condition_variable>
      17             : #include <mutex>
      18             : #include <queue>
      19             : 
      20             : namespace cpl
      21             : {
      22             : template <class T> class ThreadSafeQueue
      23             : {
      24             :   private:
      25             :     mutable std::mutex m_mutex{};
      26             :     std::condition_variable m_cv{};
      27             :     std::queue<T> m_queue{};
      28             : 
      29             :   public:
      30        3582 :     ThreadSafeQueue() = default;
      31             : 
      32           5 :     void clear()
      33             :     {
      34          10 :         std::lock_guard<std::mutex> lock(m_mutex);
      35         121 :         while (!m_queue.empty())
      36         116 :             m_queue.pop();
      37           5 :     }
      38             : 
      39          17 :     bool empty() const
      40             :     {
      41          34 :         std::lock_guard<std::mutex> lock(m_mutex);
      42          34 :         return m_queue.empty();
      43             :     }
      44             : 
      45      227484 :     size_t size() const
      46             :     {
      47      454968 :         std::lock_guard<std::mutex> lock(m_mutex);
      48      454968 :         return m_queue.size();
      49             :     }
      50             : 
      51          12 :     void push(const T &value)
      52             :     {
      53          24 :         std::lock_guard<std::mutex> lock(m_mutex);
      54          12 :         m_queue.push(value);
      55          12 :         m_cv.notify_one();
      56          12 :     }
      57             : 
      58        1018 :     void push(T &&value)
      59             :     {
      60        2036 :         std::lock_guard<std::mutex> lock(m_mutex);
      61        1018 :         m_queue.push(std::move(value));
      62        1018 :         m_cv.notify_one();
      63        1018 :     }
      64             : 
      65         885 :     T get_and_pop_front()
      66             :     {
      67        1769 :         std::unique_lock<std::mutex> lock(m_mutex);
      68        1309 :         while (m_queue.empty())
      69             :         {
      70         424 :             m_cv.wait(lock);
      71             :         }
      72         885 :         T val = m_queue.front();
      73         885 :         m_queue.pop();
      74        1770 :         return val;
      75             :     }
      76             : };
      77             : 
      78             : }  // namespace cpl
      79             : 
      80             : #endif  // CPL_THREADSAFE_QUEUE_INCLUDED