C++ में कैशिंग: Redis, Memcached और अंतर्निहित समाधान

शुरुआती लोगों के लिए ऑनलाइन Python प्रशिक्षक

Python आसानी से सीखें बिना सिद्धांत के बोझ के। स्वचालित जांच के साथ व्यावहारिक कार्य हल करें और ब्राउज़र में सीधे कोड लिखें।

पाठ्यक्रम शुरू करें

परिचय: C++ में कैशिंग की आवश्यकता क्यों है?

C++ में आधुनिक विकास में, एप्लिकेशन की गति अक्सर एक महत्वपूर्ण कारक होती है। कैशिंग डेटा तक पहुंच के समय को काफी कम करने, डेटाबेस पर लोड कम करने और बार-बार होने वाली कम्प्यूटेशनल संक्रियाओं को गति देने में मदद करता है। इस लेख में, हम C++ में कैशिंग के तीन मुख्य दृष्टिकोणों पर विस्तार से चर्चा करेंगे: बाहरी सिस्टम (Redis और Memcached) का उपयोग और "बॉक्स से बाहर" उपलब्ध अंतर्निहित समाधान।

चाहे आप एक उच्च-लोड वेब सर्वर, गेम इंजन या वित्तीय प्रणाली विकसित कर रहे हों, कैशिंग रणनीति का सही चुनाव प्रदर्शन को दस गुना तक बढ़ा सकता है। हम प्रत्येक दृष्टिकोण के फायदे और नुकसान पर चर्चा करेंगे, साथ ही त्वरित एकीकरण के लिए तैयार कोड उदाहरण भी प्रदान करेंगे।

1. C++ में कैशिंग के लिए अंतर्निहित समाधान

बाहरी सेवाओं को जोड़ने से पहले, C++ भाषा और इसकी मानक लाइब्रेरी द्वारा प्रदान की जाने वाली क्षमताओं पर विचार करना उचित है। अंतर्निहित समाधान सिंगल-थ्रेडेड एप्लिकेशन या उन मामलों के लिए आदर्श हैं जहां डेटा को कई प्रक्रियाओं के बीच साझा करने की आवश्यकता नहीं है।

1.1. `std::unordered_map` पर आधारित सरल LRU-कैश

LRU (Least Recently Used) एल्गोरिदम अंतर्निहित कैशिंग के लिए सबसे लोकप्रिय में से एक है। जब कैश मेमोरी सीमा तक पहुँच जाता है, तो यह स्वचालित रूप से सबसे कम उपयोग किए जाने वाले तत्वों को हटा देता है।

#include <unordered_map>#include <list>#include <mutex>

template <typename Key, typename Value>class LRUCache {private:    size_t capacity_;    std::list<Key> items_;    std::unordered_map<Key, std::pair<Value, typename std::list<Key>::iterator>> cache_;    std::mutex mutex_;

public:    LRUCache(size_t capacity) : capacity_(capacity) {}

    void put(const Key& key, const Value& value) {        std::lock_guard<std::mutex> lock(mutex_);        auto it = cache_.find(key);        if (it != cache_.end()) {            items_.erase(it->second.second);            cache_.erase(it);        }        items_.push_front(key);        cache_[key] = {value, items_.begin()};                if (cache_.size() > capacity_) {            auto last = items_.back();            items_.pop_back();            cache_.erase(last);        }    }

    std::optional<Value> get(const Key& key) {        std::lock_guard<std::mutex> lock(mutex_);        auto it = cache_.find(key);        if (it == cache_.end()) return std::nullopt;                // कुंजी को सूची की शुरुआत में ले जाएँ        items_.splice(items_.begin(), items_, it->second.second);        return it->second.first;    }};

लाभ: न्यूनतम ओवरहेड, कोई नेटवर्क विलंब नहीं, डेटा पर पूर्ण नियंत्रण।

नुकसान: डेटा थ्रेड्स के बीच साझा नहीं होता (मैन्युअल सिंक्रोनाइज़ेशन आवश्यक), एक प्रक्रिया की मेमोरी तक सीमित।

1.2. मल्टीथ्रेडिंग के लिए `std::shared_mutex` का उपयोग

मल्टीथ्रेडेड एप्लिकेशन के लिए, shared_mutex का उपयोग करके प्रदर्शन में सुधार किया जा सकता है, जो कई थ्रेड्स को एक साथ पढ़ने की अनुमति देता है:

#include <shared_mutex>

class ThreadSafeCache {    std::map<std::string, std::string> data_;    mutable std::shared_mutex mutex_;    public:    std::string read(const std::string& key) {        std::shared_lock lock(mutex_);        auto it = data_.find(key);        return (it != data_.end()) ? it->second : "";    }        void write(const std::string& key, const std::string& value) {        std::unique_lock lock(mutex_);        data_[key] = value;    }};