1 सेकंड

Question

में लूप एन बार निष्पादित करने के लिए कैसे मैं एक सेकंड में दो बार निर्देश या एक समारोह निष्पादित करने की कोशिश कर रहा हूं। मैं जावा में यह कैसे कर सकता हूं? के रूप में इस प्रकार है ...

//in one second 
while(N) 
{ 
    printf("........."); 
    int x=0; 
    printf("The value of x is "); 
} 

लेकिन सवाल वास्तव में बेहतर जानकारी .. मैं मैन्युअल पिक्सल प्लॉट करने के लिए कोशिश कर रहा हूँ चला जाता है और मैं दूसरा प्रभाव प्रति रोटेशन का कोई चाहता हूँ ... इसलिए मूल रूप से, यह एन निष्पादित करने के लिए है एक पल के लिए बार (लेकिन इस असीम किया जाता है) पहले से

धन्यवाद

Answer 1

आप यकीन है कि यह प्रति सेकंड बिल्कुल N बार क्या होगा कभी नहीं हो सकता है, लेकिन यह इस प्रकार है:

long taskTime = 0; 
long sleepTime = 1000/N; 
while (true) { 
    taskTime = System.currentTimeMillis(); 
    //do something 
    taskTime = System.currentTimeMillis()-taskTime; 
    if (sleepTime-taskTime > 0) { 
    Thread.sleep(sleepTime-taskTime); 
    } 
} 

Answer 2

लूप को while(true) पर बदलें।

अपने while लूप से पहले मिलीसेकंड में समय की जांच करें। while लूप के अंत में मिलीसेकंड में समय मिलता है और देखें कि उनमें से 1000 पास हुए हैं या नहीं। यदि ऐसा है तो break।

Answer 3

छद्म कोड:

Create Timer t; 
t.Start; 
int counter = N; 
While ((t.Elapsedtime < 1 Second) AND (N > 0)) 
{ 
    call your_function(); 
    N--; 
} 

your_function() 
{ 
    printf("........."); 
    int x=0; 
    printf("The value of x is "); 
} 

Answer 4

long start = System.currentTimeMillis(); 
while (System.currentTimeMillis() - start <= 1000) { 
    // Your code goes here 
} 

सभी यह ख्याल रखता है कि अपने कोड 1000 मिलिसेकंड के लिए खत्म हो लूप में चलाया जाएगा। यह कितनी बार किया गया है अनिश्चित है और प्रत्येक रन पर भिन्न हो सकता है।

Answer 5

मैं इस मुद्दे को फ़्लिप कर दूंगा: लूप को एक बार में एन बार सीमित न करें। इसके बजाए, काम की एन इकाइयों को वांछित समय पर समान रूप से वितरित किया जाता है।

है, गणना कितना समय के बाद से (या पिछले काम) शुरू बीत चुका है, को जोड़ है कि काम की दर में, और है कि ज्यादा काम (शुरुआत में कारक/पिछले समय और काम की मात्रा जो किया गया है)। यह कई गेम/एनीमेशन इंजनों का मौलिक आधार है - "delta time"।

फिर प्रत्येक लूप के अंत में "अच्छा होने" के लिए yield पर कॉल करें - या बल्कि 99% + CPU उपयोग खाने से रोकने के लिए! उपज में न्यूनतम संकल्प है, लेकिन आम तौर पर प्रभाव पर्याप्त होते हैं, खासकर जब उचित रूप से इंटरपोलिंग करते हैं।

क्योंकि एक इंटरपोलेशन दृष्टिकोण का उपयोग किया जाता है, यह आवंटित समय में सभी एन ( चला सकता है) के लिए काम करना चाहिए, भले ही इसका मतलब है कि प्रत्येक लूप को और अधिक एन करना है। यह भी संभव है कि एक छोटे से एन के लिए कोई विशेष लूप नहीं किया जा सकता है लेकिन yield CPU उपयोग के मामले में सस्ता "अतिरिक्त व्यस्त लूपिंग" सस्ता बनाता है।

---

यहाँ कुछ छद्म कोड एक दूसरे, में 20 "x" रों बाहर मुद्रित करने के लिए है, जहां now रिटर्न आंशिक सेकंड:

rate = 20  // per second - "N times per second" 
done = 0 
goal = 1 * rate // same as rate for 1 second 
start = now() 
while done < goal: 
    target = floor((now() - start) * rate) 
    work = (target - done) // work might be 0, that's okay 
    for 0 upto work: 
     print("x") 
    done += work 
    yield() 

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

---

एक वास्तविकsleep/yield के समय संकल्प कार्यान्वयन पर निर्भर है और प्रणाली द्वारा से भिन्न होता है। उदाहरण के लिए, यह 1ms on Linux to 10-15ms on windows जितना कम हो सकता है।

एक समय डेल्टा के साथ काम करने के लिए इसके अलावा, sleep अवधि प्रति दारिउज़ Wawer के जवाब के रूप में, बदला जा सकता है। हालांकि, यह जटिलता जोड़ता है और एक साधारण yield अक्सर पर्याप्त होता है।

Answer 6

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

long startTime = System.currentTimeMillis(); 
long msPerIteration = 1000000/iterationsPerSecond; 
long i=0; 
while (true) { 
    // do stuff 

    long msWaiting = startTime + (msPerIteration * ++i) - System.currentTimeMillis(); 

    if (msWaiting > 0) 
     Thread.sleep(msWaiting); 
}