参考leveldb LRU cache 写模版&线程安全&引用计数安全 lru cache

#pragma once

#include <list>
#include <unordered_map>
#include <mutex>
#include <algorithm>
#include <assert.h>

/**
 * @brief Template cache with an LRU removal policy.
 * synchronized and thread-safe
 * reference from https://github.com/google/leveldb/blob/master/util/cache.cc
 *                https://github.com/paudley/lru_cache
 */

#if   __cplusplus >= 201703L
    template< class Key, class Data, size_t (*cap_fun)(const Data&) =  [](const Data& data) constexpr ->size_t  {return sizeof(data);}, void (*delete_fun)(Data&) = [](Data& data) constexpr{}, class Hash = std::hash<Key> >
#else
    template <typename T>
    static size_t default_cap_fun(const T& data) {
        return sizeof(data);
    }

    template <typename T>
    static void default_delete_fun(T& data) {}

    template< typename Key, typename Data, size_t (*cap_fun)(const Data&) = default_cap_fun<Data>, void (*delete_fun)(Data&) = default_delete_fun<Data>, typename Hash = std::hash<Key> >
#endif

class RefLRUCache
{
public:
    struct Node;
    typedef std::list<Node> List;                             // Main cache storage typedef
    typedef typename List::iterator Node_Iter;                // Main cache iterator
    typedef typename List::const_iterator Node_cIter;         // Main cache iterator (const)
    typedef std::unordered_map<Key, Node_Iter, Hash> Map;     // Index typedef
    typedef typename Map::iterator Map_Iter;                  // Index iterator
    typedef typename Map::const_iterator Map_cIter;           // Index iterator (const)

    struct Node
    {
        Node(Key key_, Data value_, int32_t refs_, bool in_use_, bool in_lru_):
            key(key_),
            value(value_),
            refs(refs_),
            in_use(in_use_),
            in_lru(in_lru_),
            charge(cap_fun(value_)),
            trash_it()
        {}

        Key       key;
        Data      value;
        int32_t   refs;
        bool      in_use;
        bool      in_lru;
        size_t    charge;
        Node_Iter trash_it;
    };

public:
    RefLRUCache()                                = delete;
    RefLRUCache(const RefLRUCache&)              = delete;
    RefLRUCache& operator= (const RefLRUCache&)  = delete;
    RefLRUCache(RefLRUCache&&)                   = delete;
    RefLRUCache& operator= (const RefLRUCache&&) = delete;

    explicit RefLRUCache(uint64_t mem_capacity) :
        _mem_capacity(mem_capacity),
        _mem_usage(0)
    {}

    ~RefLRUCache() {
        assert(_use.empty());
        assert(_trash.empty());
        for_each(_lru.begin(), _lru.end(),
                 [](Node& elem) {
                     elem.in_lru = false;
                     elem.in_use = false;
                     _unref(elem);
        });

        _lru.clear();
        _index.clear();
    }

    /** @brief returns the number of elements.
     */
    inline size_t size() const {
        std::lock_guard<std::mutex> lock(_mutex);
        return _index.size();
    }

    inline uint64_t mem_capacity() const {
        std::lock_guard<std::mutex> lock(_mutex);
        return _mem_capacity;
    }

    inline uint64_t mem_usage() const {
        std::lock_guard<std::mutex> lock(_mutex);
        return _mem_usage;
    }

    /** @brief Removes a key-node from the cache.
     */
    inline void erase( const Key &key ) {
        std::unique_lock<std::mutex> lock{_mutex};
        _finish_erase(key);

        if (_mem_usage <= _mem_capacity && _lru.empty()) {
            lock.unlock();
            _space_available.notify_one();
        }
    }

    /**
     * @brief lookup_node_it function with release function ia a pair
     */
    inline Node_Iter lookup_node_it(const Key &key) {
        std::lock_guard<std::mutex> lock(_mutex);
        Map_Iter miter = _index.find(key);
        if (miter == _index.end())
            return Node_Iter();

        _ref(*(miter->second));

        return miter->second;
    }

    /** @brief release once node
     */
    inline void release(Node_Iter node_it) {
        std::unique_lock<std::mutex> lock{_mutex};
        _unref(*node_it);

        if (!_lru.empty() && _mem_usage > _mem_capacity) {
            lock.unlock();
            _space_available.notify_one();
        }
    }

    /**
     * @brief insert function with release function ia a pair
     */
    inline Node_Iter insert(const Key& key, const Data& data) {
        constexpr const std::chrono::milliseconds max_wait{10};
        while (_mem_usage > _mem_capacity && _lru.empty()) {
                std::unique_lock<std::mutex> lock{_mutex};
                _space_available.wait_for(lock, max_wait, [this] {
                    return !(_mem_usage > _mem_capacity && _lru.empty());
                });
        }

        std::lock_guard<std::mutex> lock(_mutex);
        _finish_erase(key);

        // If compiler support use emplace_front interface
        //_lru.emplace_front(key, data, 2, true, false);
        _use.push_front(Node(key, data, 2, true, false));
        _mem_usage += _use.begin()->charge;
        _index[key] = _use.begin();

        while (_mem_usage > _mem_capacity && !_lru.empty()) {
            Node_Iter liter = _lru.end();
            --liter;
            Node& node = *liter;
            _finish_erase(node.key);
        }

        return _use.begin();
    }

private:
    inline void _finish_erase(const Key &key){
        Map_Iter miter = _index.find(key);
        if (miter == _index.end())
            return;

        Node& node = *(miter->second);
        _mem_usage -= node.charge;

        if (node.in_lru) {
            _trash.splice(_trash.begin(), _lru, miter->second);
            node.in_lru = false;
            node.trash_it = _trash.begin();
        }

        if (node.in_use) {
            _trash.splice(_trash.begin(), _use, miter->second);
            node.in_use = false;
            node.trash_it = _trash.begin();
        }

        _index.erase(miter);
        _unref(node);
    }

    inline void _ref(Node& node) {
        // If on _lru list, move to _in_use list.
        if (node.refs == 1 && node.in_lru) {
            Map_Iter miter = _index.find(node.key);
            _use.splice(_use.begin(), _lru, miter->second);
            node.in_lru = false;
            node.in_use = true;
        }

        node.refs++;
    }

    inline void _unref(Node& node) {
        assert(node.refs > 0);
        node.refs--;

        if (node.refs == 0) {
            delete_fun(node.value);
            if (node.trash_it != Node_Iter()) {
                _trash.erase(node.trash_it);
            }
        }else if (node.refs == 1 && node.in_use) {
            // No longer in use; move to lru_ list.
            Map_Iter miter = _index.find(node.key);
            _lru.splice(_lru.begin(), _use, miter->second);
            node.in_lru = true;
            node.in_use = false;
        }
    }

private:
    List _lru;                // lru cache storage
    List _use;                // using cache storage
    List _trash;              // trash storage, not use cache capacity
    Map  _index;              // hashtable key is cahche key, value is irtator from cache storage(_lru,_use)
    uint64_t _mem_capacity;   // cache memory capacity
    uint64_t _mem_usage;      // cache memory usage

    std::condition_variable _space_available; // Used to signal producers when cache is not full
    mutable std::mutex _mutex;
};

#ifndef OSMIUM_THREAD_QUEUE_HPP
#define OSMIUM_THREAD_QUEUE_HPP

/*
This file is part of Osmium (https://osmcode.org/libosmium).
Copyright 2013-2020 Jochen Topf <jochen@topf.org> and others (see README).
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:
The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/

#include <chrono>
#include <condition_variable>
#include <cstddef>
#include <mutex>
#include <queue>
#include <string>
#include <utility> // IWYU pragma: keep

#ifdef OSMIUM_DEBUG_QUEUE_SIZE
# include <atomic>
# include <iostream>
#endif

namespace osmium {

    namespace thread {

        /**
         *  A thread-safe queue.
         */
        template <typename T>
        class Queue {

            /// Maximum size of this queue. If the queue is full pushing to
            /// the queue will block.
            const std::size_t m_max_size;

            /// Name of this queue (for debugging only).
            const std::string m_name;

            mutable std::mutex m_mutex;

            std::queue<T> m_queue;

            /// Used to signal consumers when data is available in the queue.
            std::condition_variable m_data_available;

            /// Used to signal producers when queue is not full.
            std::condition_variable m_space_available;

#ifdef OSMIUM_DEBUG_QUEUE_SIZE
            /// The largest size the queue has been so far.
            std::size_t m_largest_size;

            /// The number of times push() was called on the queue.
            std::atomic<int> m_push_counter;

            /// The number of times the queue was full and a thread pushing
            /// to the queue was blocked.
            std::atomic<int> m_full_counter;

            /**
             * The number of times wait_and_pop(with_timeout)() was called
             * on the queue.
             */
            std::atomic<int> m_pop_counter;

            /// The number of times the queue was full and a thread pushing
            /// to the queue was blocked.
            std::atomic<int> m_empty_counter;
#endif

        public:

            /**
             * Construct a multithreaded queue.
             *
             * @param max_size Maximum number of elements in the queue. Set to
             *                 0 for an unlimited size.
             * @param name Optional name for this queue. (Used for debugging.)
             */
            explicit Queue(std::size_t max_size = 0, std::string name = "") :
                m_max_size(max_size),
                m_name(std::move(name)),
                m_queue()
#ifdef OSMIUM_DEBUG_QUEUE_SIZE
                ,
                m_largest_size(0),
                m_push_counter(0),
                m_full_counter(0),
                m_pop_counter(0),
                m_empty_counter(0)
#endif
            {
            }

            Queue(const Queue&) = delete;
            Queue& operator=(const Queue&) = delete;

            Queue(Queue&&) = delete;
            Queue& operator=(Queue&&) = delete;

#ifdef OSMIUM_DEBUG_QUEUE_SIZE
            ~Queue() {
                std::cerr << "queue '" << m_name
                          << "' with max_size=" << m_max_size
                          << " had largest size " << m_largest_size
                          << " and was full " << m_full_counter
                          << " times in " << m_push_counter
                          << " push() calls and was empty " << m_empty_counter
                          << " times in " << m_pop_counter
                          << " pop() calls\n";
            }
#else
            ~Queue() = default;
#endif

            /**
             * Push an element onto the queue. If the queue has a max size,
             * this call will block if the queue is full.
             */
            void push(T value) {
                constexpr const std::chrono::milliseconds max_wait{10};
#ifdef OSMIUM_DEBUG_QUEUE_SIZE
                ++m_push_counter;
#endif
                if (m_max_size) {
                    while (size() >= m_max_size) {
                        std::unique_lock<std::mutex> lock{m_mutex};
                        m_space_available.wait_for(lock, max_wait, [this] {
                            return m_queue.size() < m_max_size;
                        });
#ifdef OSMIUM_DEBUG_QUEUE_SIZE
                        ++m_full_counter;
#endif
                    }
                }
                std::lock_guard<std::mutex> lock{m_mutex};
                m_queue.push(std::move(value));
#ifdef OSMIUM_DEBUG_QUEUE_SIZE
                if (m_largest_size < m_queue.size()) {
                    m_largest_size = m_queue.size();
                }
#endif
                m_data_available.notify_one();
            }

            void wait_and_pop(T& value) {
#ifdef OSMIUM_DEBUG_QUEUE_SIZE
                ++m_pop_counter;
#endif
                std::unique_lock<std::mutex> lock{m_mutex};
#ifdef OSMIUM_DEBUG_QUEUE_SIZE
                if (m_queue.empty()) {
                    ++m_empty_counter;
                }
#endif
                m_data_available.wait(lock, [this] {
                    return !m_queue.empty();
                });
                if (!m_queue.empty()) {
                    value = std::move(m_queue.front());
                    m_queue.pop();
                    lock.unlock();
                    if (m_max_size) {
                        m_space_available.notify_one();
                    }
                }
            }

            bool try_pop(T& value) {
#ifdef OSMIUM_DEBUG_QUEUE_SIZE
                ++m_pop_counter;
#endif
                {
                    std::lock_guard<std::mutex> lock{m_mutex};
                    if (m_queue.empty()) {
#ifdef OSMIUM_DEBUG_QUEUE_SIZE
                        ++m_empty_counter;
#endif
                        return false;
                    }
                    value = std::move(m_queue.front());
                    m_queue.pop();
                }
                if (m_max_size) {
                    m_space_available.notify_one();
                }
                return true;
            }

            bool empty() const {
                std::lock_guard<std::mutex> lock{m_mutex};
                return m_queue.empty();
            }

            std::size_t size() const {
                std::lock_guard<std::mutex> lock{m_mutex};
                return m_queue.size();
            }

        }; // class Queue

    } // namespace thread

} // namespace osmium

#endif // OSMIUM_THREAD_QUEUE_HPP

#include "ref_lru_cache.h"

RefLRUCache<int, uint64_t>::Node_Iter productor(RefLRUCache<int, uint64_t>& lll, int i)
{
   std::this_thread::sleep_for(chrono::nanoseconds(1000));
   RefLRUCache<int, uint64_t>::Node_Iter it = lll.lookup_node_it(i);
   if (RefLRUCache<int, uint64_t>::Node_Iter() == it)
   {
       return lll.insert(i, i*1000);
   }
   else
   {
       return it;
   }
}

void consume(RefLRUCache<int, uint64_t>& lll, RefLRUCache<int, uint64_t>::Node_Iter it)
{
   std::this_thread::sleep_for(chrono::nanoseconds(100000));
   uint64_t value = it->value;
   lll.release(it);
}

osmium::thread::Queue<RefLRUCache<int, uint64_t>::Node_Iter> outputqueue;

void productor_thread_fun(RefLRUCache<int, uint64_t>& lll)
{
    int i = 1;
    while(true)
    {
        if (i > 100000)
            break;

        outputqueue.push(productor(lll, i++));
    }
}

void consume_thread_fun(RefLRUCache<int, uint64_t>& lll)
{
    int i = 1;
    while(true)
    {
        if (i++ > 100000)
            break;

        RefLRUCache<int, uint64_t>::Node_Iter it;
        outputqueue.wait_and_pop(it);
        consume(lll, it);
    }
}

int main() {
    RefLRUCache<int, uint64_t> lll(10000);

    std::thread thhh1(productor_thread_fun, std::ref(lll));

    std::thread thhh2(consume_thread_fun, std::ref(lll));

    thhh1.join();
    thhh2.join();

    return 0;

}