आवधिक डेटा अपडेट

मैं तुरंत एक आरक्षण बनाना चाहता हूं कि हमारा कोड .NET फ्रेमवर्क के एक आभासी वातावरण (मशीन) में चलता है, जो सामान्य प्रयोजन के ऑपरेटिंग सिस्टम पर चलता है, इसलिए हमने 1-2 एमएस के भीतर भी किसी सटीकता के बारे में बात नहीं की। फिर भी, हम लौकिक सटीकता बढ़ाने के लिए अपनी शक्ति में सब कुछ करने की कोशिश करेंगे।

अक्सर हमारे कार्यक्रम में, एक निश्चित समय अंतराल के साथ कुछ जानकारी को अपडेट करना आवश्यक हो जाता है। मेरे मामले में, यह आईपी कैमरों से स्नैपशॉट (छवियों) का एक अद्यतन था। अक्सर, एप्लिकेशन का व्यावसायिक तर्क डेटा अपडेट की आवृत्ति पर कुछ सीमाएं निर्धारित करता है। इस समय के लिए 1 सेकंड है।
माथे में समाधान स्नैपशॉट अनुरोध के बाद Thread.Sleep (1000) /Task.Await (1000) स्थापित करना है।

static void Getsnapshot() { var rnd = new Random() var sleepMs = rnd.Next(0, 1000); Console.WriteLine($"[{DateTime.Now.ToString("mm:ss.ff")}] DoSomethink {sleepMs} ms"); Thread.Sleep(sleepMs); } while (true) { Getsnapshot(); Thread.Sleep(1000); } 

लेकिन हमारे ऑपरेशन का शब्द एक गैर-नियतात्मक मात्रा है। इसलिए, स्नैपशॉट लेने का अनुकरण कुछ इस तरह दिखता है:

हमारा प्रोग्राम चलाएं और आउटपुट चलाएं

 [15:10.39] DoSomethink 974 ms [15:12.39] DoSomethink 383 ms [15:13.78] DoSomethink 99 ms [15:14.88] DoSomethink 454 ms [15:16.33] DoSomethink 315 ms [15:17.65] DoSomethink 498 ms [15:19.15] DoSomethink 708 ms [15:20.86] DoSomethink 64 ms [15:21.92] DoSomethink 776 ms [15:23.70] DoSomethink 762 ms [15:25.46] DoSomethink 123 ms [15:26.59] DoSomethink 36 ms [15:27.62] DoSomethink 650 ms [15:29.28] DoSomethink 510 ms [15:30.79] DoSomethink 257 ms [15:32.04] DoSomethink 602 ms [15:33.65] DoSomethink 542 ms [15:35.19] DoSomethink 286 ms [15:36.48] DoSomethink 673 ms [15:38.16] DoSomethink 749 ms 

जैसा कि हम देखते हैं कि अंतराल जमा होगा और इसलिए हमारे आवेदन के व्यापारिक तर्क का उल्लंघन किया जाएगा।

 ,      60   1      49. 

आप औसत विचलन को कम करके नींद के औसत को मापने और नींद के समय को कम करने की कोशिश कर सकते हैं, लेकिन इस मामले में हम अपने व्यावसायिक तर्क की तुलना में अधिक अनुरोध प्राप्त कर सकते हैं। हम यह अनुमान लगाने में कभी सक्षम नहीं होंगे कि यह जानते हुए कि अनुरोध 1 सेकंड तक पूरा हो गया है - आवश्यक अद्यतन अवधि सुनिश्चित करने के लिए हमें कितने मिलीसेकंड की प्रतीक्षा करनी होगी।

 ,      60   1     62. 

स्पष्ट समाधान ही सुझाव देता है। ऑपरेशन से पहले और बाद के समय को मापें। और उनके अंतर की गणना करें।

 while (true) { int sleepMs = 1000; var watch = Stopwatch.StartNew(); watch.Start(); Getsnapshot(); watch.Stop(); int needSleepMs = (int)(sleepMs - watch.ElapsedMilliseconds); Thread.Sleep(needSleepMs); } 

अब हमारे कार्यक्रम को चलाएं। यदि आप भाग्यशाली हैं, तो आपको निम्नलिखित में से कुछ दिखाई देगा।

 [16:57.25] DoSomethink 789 ms [16:58.05] Need sleep 192 ms [16:58.25] DoSomethink 436 ms [16:58.68] Need sleep 564 ms [16:59.25] DoSomethink 810 ms [17:00.06] Need sleep 190 ms [17:00.25] DoSomethink 302 ms [17:00.55] Need sleep 697 ms [17:01.25] DoSomethink 819 ms [17:02.07] Need sleep 181 ms [17:02.25] DoSomethink 872 ms [17:03.13] Need sleep 128 ms [17:03.25] DoSomethink 902 ms [17:04.16] Need sleep 98 ms [17:04.26] DoSomethink 717 ms [17:04.97] Need sleep 282 ms [17:05.26] DoSomethink 14 ms [17:05.27] Need sleep 985 ms 

अगर मैं भाग्यशाली हूं तो मैंने क्यों लिखा? क्योंकि watch.Start () DoSomethink () और watch.Stop () DoSomethink () के बाद निष्पादित किया जाता है; ये ऑपरेशन तात्कालिक नहीं हैं + रनटाइम वातावरण स्वयं प्रोग्राम निष्पादन समय (x) की सटीकता की गारंटी नहीं देता है। इसलिए, ओवरहेड होगा। हमारा DoSomethink () फंक्शन 0-1000 ms (y) से चलता है। इसलिए, ऐसे मामलों में x + y> 1000 होने पर स्थितियां उत्पन्न हो सकती हैं

  int needSleepMs = (int)(sleepMs - watch.ElapsedMilliseconds); 

नकारात्मक मान लेगा और हमें एक ArgumentOutOfRangeException मिल जाएगी, क्योंकि Thread.Sleep () विधि नकारात्मक मान नहीं लेना चाहिए।

इस तरह के मामलों में, यह आवश्यक है कि जरूरतमंदों के समय को 0 पर सेट किया जाए;
वास्तव में, वास्तव में, DoSomethink () फ़ंक्शन जब तक आप चाहें, तब तक निष्पादित कर सकते हैं और इंट में कास्टिंग करते समय हम चर अतिप्रवाह प्राप्त कर सकते हैं। फिर हमारे सोने का समय
नींद से अधिक हो सकता है;

आप इसे इस प्रकार ठीक कर सकते हैं:

 var needSleepMs = sleepMs - watch.ElapsedMilliseconds; if (needSleepMs > 0 && watch.ElapsedMilliseconds <= sleepMs) { needSleepMs = (int)needSleepMs; } else { needSleepMs = 0; } Thread.Sleep(needSleepMs); 

सिद्धांत रूप में, सब कुछ तैयार है। लेकिन 1 स्थान पर भी इस दृष्टिकोण का उपयोग करने से प्रोग्रामर की आंख के लिए असुविधा होती है। और अगर कार्यक्रम में दर्जनों ऐसे स्थान हैं, तो कोड एक अपठनीय ढेर में बदल जाएगा ...

इसे ठीक करने के लिए, हम एक फ़ंक्शन में अपने कोड को इनकैप्सुलेट करते हैं। यहां आप इसे एक अलग वर्ग में रख सकते हैं या कक्षा के लिए एक नियमित डंप के रूप में ग्लोबल का उपयोग कर सकते हैं और इसे स्थिर (मेरा संस्करण) के रूप में उपयोग कर सकते हैं।

हमारे उदाहरण में, इसे सरलता के लिए छोड़ दें, इसे प्रोग्राम क्लास में छोड़ दें

 public static int NeedWaitMs(Action before, int sleepMs) { var watch = Stopwatch.StartNew(); watch.Start(); before(); watch.Stop(); var needSleepMs = sleepMs - watch.ElapsedMilliseconds; if (needSleepMs > 0 && watch.ElapsedMilliseconds <= sleepMs) return (int) needSleepMs; return 0; } 

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

कार्यक्रम की पूरी सूची नीचे दी गई है:

 using System; using System.Diagnostics; using System.Threading; namespace ConsoleApp2 { class Program { static void Getsnapshot() { var rnd = new Random(); var sleepMs = rnd.Next(0, 1000); Console.WriteLine($"[{DateTime.Now.ToString("mm:ss.ff")}] DoSomethink {sleepMs} ms"); Thread.Sleep(sleepMs); } static void Main(string[] args) { while (true) { var sleepMs = NeedWaitMs(Getsnapshot, 1000); Console.WriteLine($"[{DateTime.Now.ToString("mm:ss.ff")}] Need sleep {sleepMs} ms {Environment.NewLine}"); Thread.Sleep(sleepMs); } } public static int NeedWaitMs(Action before, int sleepMs) { var watch = Stopwatch.StartNew(); before(); watch.Stop(); var needSleepMs = sleepMs - watch.ElapsedMilliseconds; return needSleepMs > 0 ? (int) needSleepMs : 0; } } }