बाहर निकलें सी #

Question

में विशिष्ट समय के बाद पाश मैं अपने प्रोजेक्ट (सी #, VS2010, .NET 4.0) है कि एक विशेष for पाश 200 मिलीसेकेंड के भीतर समाप्त करना चाहिए में एक आवश्यकता है। यदि ऐसा नहीं होता है तो शेष अवधि को निष्पादित किए बिना इस अवधि के बाद इसे समाप्त करना होगा। लूप आमतौर पर i = 0 के लिए लगभग 500,000 से 700,000 तक जाता है, इसलिए कुल लूप समय भिन्न होता है।

मैं निम्नलिखित प्रश्न जो समान हैं पढ़ा है, लेकिन वे मेरे मामले में मदद नहीं की:

1. What is the best way to exit out of a loop after an elapsed time of 30ms in C++
2. How to execute the loop for specific time

अब तक मैं ट्रैक करने के लिए एक Stopwatch वस्तु का उपयोग कर की कोशिश की है विलुप्त समय लेकिन यह मेरे लिए काम नहीं कर रहा है।

विधि 1.for पाश के भीतर बीता हुआ समय की तुलना करना:: यहाँ 2 अलग अलग तरीकों मैं अब तक की कोशिश की है कर रहे हैं

Stopwatch sw = new Stopwatch(); 
sw.Start(); 

for (i = 0; i < nEntries; i++) // nEntries is typically more than 500,000 
{ 
     // Do some stuff 
     ... 
     ... 
     ... 

     if (sw.Elapsed > TimeSpan.FromMilliseconds(200)) 
      break; 
} 

sw.Stop(); 

यह काम नहीं करता क्योंकि if (sw.Elapsed > TimeSpan.FromMilliseconds(200)) पूरा करने के लिए 200 से अधिक मिलीसेकेंड लेता है। इसलिए मेरे मामले में बेकार। मुझे यकीन नहीं है कि TimeSpan.FromMilliseconds() आमतौर पर यह लंबा लगता है या यह किसी कारण से मेरे मामले में है।

विधि 2. समय की तुलना करने के एक अलग थ्रेड बनाना:

Stopwatch sw = new Stopwatch(); 
sw.Start();      
bool bDoExit = false; 
int msLimit = 200; 

System.Threading.ThreadPool.QueueUserWorkItem((x) => 
{ 
    while (bDoExit == false) 
    { 
     if (sw.Elapsed.Milliseconds > msLimit) 
     { 
      bDoExit = true; 
      sw.Stop(); 
     } 

     System.Threading.Thread.Sleep(10); 
     } 

}); 

for (i = 0; i < nEntries; i++) // nEntries is typically more than 500,000 
{ 
     // Do some stuff 
     ... 
     ... 
     ... 

     if (bDoExit == true) 
      break; 
} 

sw.Stop(); 

मैं में कुछ अन्य कोड है पाश है कि कुछ आंकड़े प्रिंट के लिए। यह मुझे बताता है कि विधि 2 के मामले में, for लूप निश्चित रूप से सभी पुनरावृत्तियों को पूरा करने से पहले टूट जाता है लेकिन लूप समय अभी भी 280-300 मिलीसेकंड है।

200 मिलीसेकंड या उससे कम के साथ सख्ती से लूप को तोड़ने के लिए कोई सुझाव? धन्यवाद।

Answer 1

एक तेजी से तुलना के लिए

if(sw.ElapsedMilliseconds > 200) 
    break; 

की तुलना की कोशिश आप अपने पाश की शुरुआत में उस चेक करते हैं और प्रसंस्करण के दौरान भी चाहिए, ("// कुछ सामान है" कोड का हिस्सा), क्योंकि यह है उदाहरण के लिए, यह प्रसंस्करण 1 9 0 (लूप की शुरुआत) से शुरू होता है, 20 रहता है और 210 पर समाप्त होता है।

आप अपने प्रसंस्करण के औसत निष्पादन समय को भी माप सकते हैं (यह अनुमानित है क्योंकि यह औसत समय पर निर्भर करता है), इस तरह लूप को 200 मिलीसेकंड या उससे कम समय तक चलना चाहिए, यहां एक डेमो है जिसे आप मुख्य विधि में डाल सकते हैं कंसोल आवेदन और आसानी से अपने आवेदन के लिए इसे संशोधित:

 Stopwatch sw = new Stopwatch(); 
     sw.Start(); 

     string a = String.Empty; 
     int i; 
     decimal sum = 0, avg = 0, beginning = 0, end = 0; 
     for (i = 0; i < 700000; i++) // nEntries is typically more than 500,000 
     { 
      beginning = sw.ElapsedMilliseconds; 
      if (sw.ElapsedMilliseconds + avg > 200) 
       break; 

      // Some processing 
      a += "x"; 
      int s = a.Length * 100; 
      Thread.Sleep(19); 
      ///////////// 

      end = sw.ElapsedMilliseconds; 
      sum += end - beginning; 
      avg = sum/(i + 1); 

     } 
     sw.Stop(); 

     Console.WriteLine(
      "avg:{0}, count:{1}, milliseconds elapsed:{2}", avg, i + 1, 
      sw.ElapsedMilliseconds); 
     Console.ReadKey(); 

Answer 2

पहले एक का उपयोग करें - सरल और दूसरे की तुलना में सटीक होने की बेहतर संभावनाएं हैं।

दोनों मामलों में एक ही तरह की समाप्ति की स्थिति है, इसलिए दोनों को व्यवहार करना चाहिए उतना ही कम या कम। धागे और नींद के उपयोग के कारण दूसरा अधिक जटिल है, इसलिए मैं पहले का उपयोग करता हूं। सोने के कारण दूसरा भी बहुत कम सटीक है।

TimeSpan.FromMilliseconds(200) के लिए कोई महत्वपूर्ण समय लेने के लिए बिल्कुल कोई कारण नहीं है (साथ ही इसे प्रत्येक पुनरावृत्ति में कॉल करना)।

Answer 3

मैं अगर यह है कि वास्तव में नहीं पता है, लेकिन मुझे लगता है कि का उपयोग कर एक System.Timers.Timer एक कोशिश के लायक है:

int msLimit = 200; 
int nEntries = 500000; 
bool cancel = false; 

System.Timers.Timer t = new System.Timers.Timer(); 
t.Interval = msLimit; 
t.Elapsed += (s, e) => cancel = true; 
t.Start(); 

for (int i = 0; i < nEntries; i++) 
{ 
    // do sth 

    if (cancel) { 
     break; 
    } 
} 

Answer 4

एक अन्य विकल्प होगा CancellationTokenSo का उपयोग करने के लिए urce:

CancellationTokenSource source = new CancellationTokenSource(100); 

while(!source.IsCancellationRequested) 
{ 
    // Do stuff 
}