लॉक-फ्री मेमचैच एपीआई

शुभ दिन, ह्रज़ितली!
यह पोस्ट कई घंटों के विचार, एक पेपर-क्लिप, कोड ड्राफ्ट और अंत में, वास्तव में उत्पादन में काम कर रहे कोड का एक संक्षिप्त सारांश है।
हमारी साइट (और उसके बाद बस एक साइट) सक्रिय रूप से गर्म डेटा के लिए मेमेक का उपयोग करती है। मेमेकेश को भरने वाला कोड बहुत लंबे समय तक काम कर सकता है (0.5 सेकंड एक लंबा समय है) और उसी समय उपयोगकर्ता अनुरोध एक और सौ अपडेट प्रक्रिया शुरू करने का प्रबंधन करता है। परिणाम समझ में आते हैं, लेकिन लंबे समय तक हम उन्हें कुल भार के स्तर पर नोटिस नहीं कर सकते। केवल जब हमने कुछ अनुरोधों को बढ़ाने के लिए समय के फटने को देखा (बढ़े हुए लोड से, वे SLOW_QUERIES_LOG MySQL में भी गिर गए) - तो काम उबलने लगा।

समस्या स्पष्ट है

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



अद्यतन तर्क कोड द्वारा नियंत्रित किया जाता है, अर्थात्। एप्लिकेशन को स्वयं पता होता है कि क्या यह FALSE लौटा है, तो आपको कुंजी को फिर से बनाने की आवश्यकता है। जैसा कि आप आरेख से देख सकते हैं, उस समय परेशानी पैदा होती है जब पहले अनुरोध पर डेटा को अभी "तैयार" करने का समय नहीं हुआ है, और हम पहले से ही उसी डेटा के लिए पूछ रहे हैं।
सटीक परिभाषा के लिए badbloodydemon habruiser के लिए धन्यवाद - स्थिति को "डॉग पाइल इफेक्ट" कहा जाता है।

निर्णय

कई संस्करणों को आगे रखा गया है - इससे कैसे बचा जाए।
पहले, हमने लॉक सिस्टम और अपडेट कतार के बारे में सोचा। लेकिन यह परिदृश्य बहुत ही धीमा है।
फिर हमने सोचा कि - अगर कोड डेटा को पुन: उत्पन्न कर सकता है - तो उसे ऐसा करने दें। आपको बस इसे FALSE करने की आवश्यकता है। और तुरंत, पुराने डेटा को पुनर्स्थापित करें। कुल: अद्यतन प्रक्रिया एक बार लॉन्च की जाएगी, और पुनर्जनन प्रक्रिया के अंत तक आवेदन पर वापस आने वाले डेटा को केवल पुनर्जनन की अवधि के लिए "रॉट आउट" किया जाता है।
ऐसा करने के लिए, हमें केवल डेटा ही नहीं, बल्कि टाइमआउट और कुंजी को अमान्य करने के लिए मेमकेश में जोड़ना होगा। एक समय के लिए दो बार बड़े (निश्चित होने के लिए) एक सरणी एक वास्तविक मेम्केश में मिलती है। प्रलेखन का कहना है कि सबसे लंबी कुंजी भंडारण का समय 30 दिन है। यानी सिर्फ 15 दिनों के लिए "रैपर" डेटा में रखें - निष्ठा के लिए 1 सेकंड। वही एक समय-सीमा = 0 के साथ कुंजियों पर लागू होता है (यानी, हमेशा के लिए, जब तक कि यह भीड़ से बाहर न हो जाए)। 15 दिनों में एक बार जब एक मेमेश में डेटा की आवश्यकता होती है, तो स्थिति - मैं नहीं मिला। यदि आपके साथ ऐसा हुआ है, तो कुछ को बदलने की जरूरत है।
हमने वेतन वृद्धि पर भी ध्यान दिया। मुझे इस बात से सहमत होना था कि सभी वेतन वृद्धि की कुंजी "_inc" में है, उदाहरण के लिए। और जब इस तरह की कुंजी मिल जाती है, तो हमें बस आवश्यक डेटा प्राप्त होता है, जिसे मेमोरेश ने ही बढ़ाया है। * मैंने यह कांटा या मेम्काचे_प्रॉक्सी :: get () विधि को हटा दिया।

कोड

कोड का दस्तावेजीकरण किया जाता है जहां इसकी आवश्यकता होती है :) मैं कोड शीट के लिए पहले से माफी मांगता हूं, लेकिन मैं इसे अब नहीं काट सकता।

class MC { private static $_proxy; // Singleton for our class, extended of native Memcache class private static function _proxy() { if (is_null(self::$_proxy) || self::$_proxy->closed) self::$_proxy = new Memcache_Proxy; return self::$_proxy; } public static function get($key = '') { return self::_proxy()->get($key); } public static function set($key = '', $data = NULL, $flag = FALSE, $timeout = 3600) { return self::_proxy()->set($key, $data, $flag, $timeout); } public static function delete($key = '') { return self::_proxy()->delete($key); } public static function increment($key = '', $increment = 1) { return self::_proxy()->increment($key, $increment); } } 

एमएस वर्ग को पूरे कोड के भीतर मेम्चे के एक उदाहरण के साथ संचार करने की आवश्यकता है, ताकि स्पष्ट रूप से मेकचे को कनेक्शन घोषित करने की आवश्यकता न हो। यह पहली बार बनाया जाएगा जब आप इस वर्ग में वांछित विधि कहते हैं।

 class Memcache_Proxy extends Memcache { public $closed = false; public function __construct() { $this->connect(MEMCACHE_HOST, MEMCACHE_PORT, null); $this->closed = false; } function __destruct() { $this->close(); $this->closed = true; } /** * Mirror for $memcache->get() method */ public function get($key = '') { if (empty($key)) return FALSE; $data = parent::get($key); if ($data !== FALSE && $this->_is_valid_cache($data)) { if (!isset($data['_dc_cache'])) $data['_dc_cache'] = NULL; //check lifetime if (time() > $data['_dc_life_end']) { //expired, save the same for a longer time for other connections $this->set($key, $data['_dc_cache'], FALSE, $data['_dc_cache_time']); return FALSE; } else { //still alive return $data['_dc_cache']; } } return FALSE; } /** * Mirror for $memcache->set() method */ public function set($key = '', $data, $flag = FALSE, $timeout = 3600) { if (empty($key)) return FALSE; // Place here "_inc" key check if (is_int($data) || $data === FALSE) parent::delete($key . '_increment'); // Maximum timeout = 15 days - 1 second if ((int)$timeout == 0 || (int)$timeout > 1295999) $timeout = 1295999; return $this->_set($key, $data, $flag, $timeout * 2); } /** * Mirror for $memcache->delete() method */ public function delete($key = '') { if (empty($key)) return FALSE; // Magic for increment. Place here "_inc" key check parent::delete($key . '_increment'); return parent::delete($key); } public function increment($key, $increment = 1) { $inc_value = parent::increment($key . '_increment', $increment); $data = parent::get($key); if ($data === FALSE) return FALSE; if ($this->_is_valid_cache($data)) { if ($inc_value === FALSE) { $inc_value = $data['_dc_cache'] + $increment; parent::set($key . '_increment', $inc_value, FALSE, $data['_dc_cache_time'] * 2); } $time = $data['_dc_life_end'] - time(); if ($time > 0) { $this->_set($key, $inc_value, FALSE, $time); return $inc_value; } } return $inc_value; } private function _set($key = '', $data, $flag = FALSE, $timeout = 3600) { $cache = array('_dc_cache' => $data, '_dc_life_end' => time() + $timeout, '_dc_cache_time' => $timeout); return parent::set($key, $cache, $flag, $timeout); } // Maybe we have pure Memcache data, not our array structure private function _is_valid_cache($value) { return (is_array($value) && isset($value['_dc_life_end']) && isset($value['_dc_cache_time']) && !empty($value['_dc_life_end']) && !empty($value['_dc_cache_time']) ) ? TRUE : FALSE; } } 

उपयोग के उदाहरण

कोड, सिर्फ कोड। यदि डेटा खट्टा है, तो हम केवल अनुरोधकर्ता को FALSE करके जेनरेशन शुरू करते हैं और उसी समय उसी डेटा को फिर से इंस्टॉल करते हैं। इस प्रकार, अगला अनुरोधकर्ता पुराने डेटा को प्राप्त करेगा जब तक कि पहली प्रक्रिया पीढ़ी खत्म न हो जाए और वास्तविक डेटा के साथ MC :: set () निष्पादित हो। उसके तुरंत बाद, सभी प्रक्रियाओं को प्रासंगिक डेटा प्राप्त होगा।

 $data = MC::get('some_key'); if ($data === FALSE) { //     $data = huge_generate_func_call(); MC::set('some_key', $data, FALSE, 3600); } 

यानी पहले की तरह मेमकेश का उपयोग जारी रखें। यदि मेमकेश को एक्सेस करने के लिए एक रैपर था, तो आप इसे सही कर सकते हैं और एप्लिकेशन कोड में कुछ भी नहीं छू सकते हैं। यह, वैसे, आवश्यकताओं में से एक था: मेकेश के नए वर्ग की शुरूआत के लिए न्यूनतम रीफैक्टरिंग।

सारांश

आप टाइमस्टैम्प और टाइमआउट स्टोर करने के ओवरहेड पर अपनी आँखें बंद कर सकते हैं, मेमोरी अब सस्ती है।
तथ्य यह है कि डेटा पीढ़ी के समय के बराबर समय के हिसाब से डेटा "बेईमानी" घातक और सहनीय नहीं है, हालांकि, एक ही डेटा की पीढ़ी के लिए नई धाराएं नहीं बनती हैं। QED!

पुनश्च
सुझाव और टिप्पणियों का स्वागत है! वर्तनी - पीएम में, अनिवार्य रूप से - टिप्पणियों में!

युपीडी।
कॉमरेड माइनस - अपनी पसंद का तर्क देते हैं। हर कोई पुश्किन और स्ट्रैसपुप की प्रतिभाओं के साथ पैदा नहीं हुआ था!

युपीडी। 2
हम विपक्ष से निपटते हैं:
1।
MC वर्ग की आवश्यकता है ताकि कोड में कुछ भी न बदले। निश्चित रूप से। इसे अपने रैपर के नाम के साथ मेमेकेश पर बदलें, यदि कोई हो। यदि नहीं, तो अधिकांश सभ्य IDE रिफ्लेक्टर का समर्थन करते हैं -> ClassName बदलें।
2।
क्लास एमएस स्थिर है। यह ऐतिहासिक रूप से हुआ - कम से कम रिफैक्टिंग - मुख्य आवश्यकता। मैंने ह्रब के लिए कोड को फिर से शुरू नहीं किया - मुख्य विचार वहां परिलक्षित होता है।