System.currentTimeMillis()

Question

का उपयोग करके हर सेकेंड कोड चलाएं I System.currentTimeMillis(); का उपयोग कर हर सेकेंड कोड को चलाने की कोशिश कर रहा हूं।

कोड:

 while(true){ 
      long var = System.currentTimeMillis()/1000; 
      double var2 = var %2; 

      if(var2 == 1.0){ 

       //code to run 

      }//If(): 

     }//While 

कोड जो मैं चलाना चाहते हैं, क्योंकि कई बार var2 अनंत पूरे पाश की वजह से 1.0 से अधिक बार के लिए सेट है चलाता है। मैं सिर्फ कोड लाइन को चलाने के लिए चाहता हूं जब var2 पहले 1.0 पर सेट हो, और फिर हर बार फिर जब var2 0.0 के बाद 1.0 हो जाता है।

Answer 1

यदि आप सेकंड को बदलने के लिए प्रतीक्षा करना चाहते हैं तो आप निम्न का उपयोग कर सकते हैं।

long lastSec = 0; 
while(true){ 
    long sec = System.currentTimeMillis()/1000; 
    if (sec != lastSec) { 
     //code to run 
     lastSec = sec; 
    }//If(): 
}//While 

एक और अधिक कुशल दृष्टिकोण अगले दूसरे तक सोना है।

while(true) { 
    long millis = System.currentTimeMillis(); 
    //code to run 
    Thread.sleep(1000 - millis % 1000); 
}//While 

एक वैकल्पिक एक ScheduledExecutorService

ScheduledExecutorService ses = Executors.newSingleThreadScheduledExecutor(); 

ses.scheduleAtFixedRate(new Runnable() { 
    @Override 
    public void run() { 
     // code to run 
    } 
}, 0, 1, TimeUnit.SECONDS); 

// when finished 
ses.shutdown(); 

उपयोग करने के लिए इस दृष्टिकोण का लाभ यह है कि

• आप एक ही धागे को बांटने अलग-अलग समय के साथ कार्यों की एक संख्या हो सकती है है।
• आपके पास गैर-दोहराने वाली देरी या असीमित कार्य हो सकते हैं।
• आप परिणाम को अन्य थ्रेड में एकत्र कर सकते हैं।
• आप एक कमांड के साथ थ्रेड पूल को बंद कर सकते हैं।

Answer 2

आपको java.util.Timer और java.util.TimerTask कक्षा का उपयोग करना होगा।

Answer 3

Thread.sleep(); का उपयोग आपके मामले के लिए बिल्कुल सही होगा।

while(true) 
{ 
    Thread.sleep(1000); // Waiting before run. 
    // Actual work goes here. 
} 

Answer 4

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

Executors.newSingleThreadScheduledExecutor().scheduleAtFixedRate(new MyRunnable(), 0, 5, TimeUnit.SECONDS); 

हर 5 सेकंड में MyRunnable कक्षा चलाएगा। MyRunnable Runnable लागू करना चाहिए। इसके साथ समस्या यह है कि यह हर बार एक नया धागा बनायेगा (कुशलतापूर्वक) जो वांछनीय हो सकता है या नहीं।

Answer 5

पसंदीदा तरीका:

ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(); 

तब की तरह Runnables में पारित:

scheduler.scheduleWithFixedDelay(myRunnable, initDelay, delay, TimeUnit.MILLISECONDS); 

मैं टाइमर का उपयोग नहीं होता। शेड्यूलर उन समस्याओं को संभालने के लिए बनाए जाते हैं जिन्हें टाइमर का कारण बन सकता है। साथ ही, Thread.sleep एक साधारण प्रोग्राम के लिए अच्छा है जिसे आप अवधारणा प्रकार की चीजों के सबूत के लिए जल्दी लिख रहे हैं लेकिन मैं इसे एंटरप्राइज़ दुनिया में उपयोग नहीं करूँगा।