एकाधिक क्रोम.स्टॉरेज एपीआई कॉल में दौड़ की स्थिति को रोकने के लिए सबसे अच्छा तरीका है?

Question

1. कुछ कार्य
2. कुछ और कार्य सूची को स्टोरेज से बाहर खींचता है, और जांच करता है कि वहां कार्य हैं या नहीं।
3. यदि कोई कार्य है तो यह एक को हटा देता है और छोटी "कार्य सूची" को भंडारण में वापस रखा जाता है।

चरण 2 और 3 के बीच

एक दौड़ यदि एक से अधिक अनुरोध घटित हालत हो सकता है, और एक ही काम के लिए दो बार नहीं दिखाए जाएंगे।

क्या किसी अन्य अनुरोध को रोकने के लिए "कार्य तालिका" को "लॉक" करने का सही समाधान है, जबकि एक ही कार्य "चेक आउट" है?

कम से कम प्रदर्शन प्रभाव के साथ समाधान क्या है, जैसे कि निष्पादन में देरी, और क्रोम.स्टॉरेज एपीआई के साथ जावास्क्रिप्ट में इसे कैसे कार्यान्वित किया जाना चाहिए?

उदाहरण के लिए कुछ कोड:

function decide_response () { 
    if(script.replay_type == "reissue") { 
      function next_task(tasks) { 
       var no_tasks = (tasks.length == 0); 
       if(no_tasks) { 
        target_complete_responses.close_requester(); 
       } 
       else { 
        var next_task = tasks.pop(); 
        function notify_execute() { 
         target_complete_responses.notify_requester_execute(next_task); 
        } 
        setTable("tasks", tasks, notify_execute); 
       } 
      } 
      getTable("tasks", next_tasks); 
    ... 
    } 
... 
} 

Answer 1

मैं तुम्हें तथ्य यह है कि जावास्क्रिप्ट एकल पिरोया एक संदर्भ में है, यहां तक ​​कि अतुल्यकालिक chrome.storage एपीआई के साथ का फायदा उठाते हुए एक ताला के बिना प्रबंधन कर सकते हैं लगता है। जब तक आप chrome.storage.sync का उपयोग नहीं कर रहे हैं, वह है - यदि क्लाउड से परिवर्तन हो या नहीं हो तो मुझे लगता है कि सभी दांव बंद हैं। स्थानीय स्मृति में एक कतार में कॉलबैक के रूप में उपभोक्ताओं से

var getTask = (function() { 
    // Private list of requests. 
    var callbackQueue = []; 

    // This function is called when chrome.storage.local.set() has 
    // completed storing the updated task list. 
    var tasksWritten = function(nComplete) { 
    // Remove completed requests from the queue. 
    callbackQueue = callbackQueue.slice(nComplete); 

    // Handle any newly arrived requests. 
    if (callbackQueue.length) 
     chrome.storage.local.get('tasks', distributeTasks); 
    }; 

    // This function is called via chrome.storage.local.get() with the 
    // task list. 
    var distributeTasks = function(items) { 
    // Invoke callbacks with tasks. 
    var tasks = items['tasks']; 
    for (var i = 0; i < callbackQueue.length; ++i) 
     callbackQueue[i](tasks[i] || null); 

    // Update and store the task list. Pass the number of requests 
    // handled as an argument to the set() handler because the queue 
    // length may change by the time the handler is invoked. 
    chrome.storage.local.set(
     { 'tasks': tasks.slice(callbackQueue.length) }, 
     function() { 
     tasksWritten(callbackQueue.length); 
     } 
    ); 
    }; 

    // This is the public function task consumers call to get a new 
    // task. The task is returned via the callback argument. 
    return function(callback) { 
    if (callbackQueue.push(callback) === 1) 
     chrome.storage.local.get('tasks', distributeTasks); 
    }; 
})(); 

यह भंडार कार्य अनुरोध:

मैं कुछ इस तरह (कफ, नहीं परीक्षण किया है, कोई त्रुटि हैंडलिंग बट्टे खाते में डाल) करना होगा। जब कोई नया अनुरोध आता है, तो कॉलबैक कतार में जोड़ा जाता है और कार्य सूची iff प्राप्त होती है यह कतार में एकमात्र अनुरोध है। अन्यथा हम मान सकते हैं कि कतार पहले ही संसाधित की जा रही है (यह एक अंतर्निहित ताला है जो कार्य सूची तक पहुंचने के लिए केवल एक स्ट्रैंड निष्पादन की अनुमति देता है)।

जब कार्य सूची प्राप्त की जाती है, तो अनुरोध अनुरोधों को वितरित किए जाते हैं। ध्यान दें कि प्राप्त होने से पहले अधिक से अधिक पहुंचने पर एक से अधिक अनुरोध हो सकते हैं। यदि कार्य से अधिक अनुरोध हैं तो यह कोड केवल कॉलबैक पर शून्य हो जाता है। जब तक अधिक कार्य नहीं आते हैं, तब तक अनुरोधों को अवरुद्ध करने के लिए, अप्रयुक्त कॉलबैक रखें और कार्य जोड़े जाने पर अनुरोध प्रसंस्करण को पुनरारंभ करें। यदि कार्यों को गतिशील रूप से उत्पादित किया जा सकता है और साथ ही उपभोग किया जा सकता है, तो याद रखें कि दौड़ की स्थिति को भी वहां रोका जाना चाहिए, लेकिन यहां नहीं दिखाया गया है।

अद्यतन कार्य सूची संग्रहीत होने तक कार्य सूची को फिर से पढ़ने से रोकना महत्वपूर्ण है। इसे पूरा करने के लिए, जब तक अद्यतन पूरा नहीं हो जाता है, तब तक कतार से अनुरोध नहीं हटाए जाते हैं। फिर हमें इस दौरान आने वाले किसी भी अनुरोध को संसाधित करना सुनिश्चित करना होगा (chrome.storage.local.get() पर कॉल को शॉर्ट सर्किट करना संभव है, लेकिन मैंने सादगी के लिए ऐसा किया है)।

यह दृष्टिकोण इस अर्थ में बहुत ही कुशल होना चाहिए कि इसे कार्य सूची में अपडेट को कम से कम करना चाहिए जबकि अभी भी जितनी जल्दी हो सके प्रतिक्रिया देनी चाहिए। कोई स्पष्ट लॉकिंग या प्रतीक्षा नहीं है। यदि आपके पास अन्य संदर्भों में उपभोक्ताओं को कार्य है, तो chrome.extension संदेश हैंडलर सेट करें जो GetTask() फ़ंक्शन को कॉल करता है।