हर X सेकंड "हैलो वर्ल्ड" प्रिंट करें

Question

हाल ही में मैं बड़ी संख्या के साथ छोरों का उपयोग कर रहा हूं ताकि प्रिंट आउट हो सके Hello World:

int counter = 0;

while(true) {
    //loop for ~5 seconds
    for(int i = 0; i < 2147483647 ; i++) {
        //another loop because it's 2012 and PCs have gotten considerably faster :)
        for(int j = 0; j < 2147483647 ; j++){ ... }
    }
    System.out.println(counter + ". Hello World!");
    counter++;
}

मैं समझता हूं कि यह करने का एक बहुत ही मूर्खतापूर्ण तरीका है, लेकिन मैंने अभी तक जावा में किसी भी टाइमर लाइब्रेरी का उपयोग नहीं किया है। हर 3 सेकंड में प्रिंट करने के लिए ऊपर वाला कैसे संशोधित करेगा?

Comments

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

— इहाजबोन

हर 10 मिनट में एक फ़ंक्शन

— Alex.K.

Answer 1

तुम भी पर एक नज़र ले जा सकते हैं Timerऔर TimerTaskवर्ग है जो आप हर चलाने के लिए अपने कार्य को शेड्यूल करने के लिए उपयोग कर सकते हैं nसेकंड।

आपको एक वर्ग की आवश्यकता है जो विधि को बढ़ाता है TimerTaskऔर ओवरराइड करता public void run()है, जिसे हर उस समय निष्पादित किया जाएगा जब आप उस वर्ग के एक उदाहरण को timer.schedule()विधि में पास करते हैं।

यहाँ एक उदाहरण है, जो Hello Worldहर 5 सेकंड प्रिंट करता है: -

class SayHello extends TimerTask {
    public void run() {
       System.out.println("Hello World!"); 
    }
}

// And From your main() method or any other method
Timer timer = new Timer();
timer.schedule(new SayHello(), 0, 5000);

Comments

ध्यान दें कि 2-परम scheduleविधि निर्दिष्ट देरी के बाद एक बार निष्पादित होगी। 3-परम scheduleया scheduleAtFixedRateउपयोग करने की आवश्यकता होगी।

— टिम बेंडर

हा हा हां। कभी-कभी मुझे उत्तरों पर वोट मिल जाते हैं और मैं यह देखने के लिए जाता हूं कि समाधान प्रदान करने के बाद मैंने अपनी अंतिम समझ में सुधार किया है।

— टिम बेंडर

@TimBender सोच रहा था कि क्या ओपी को वास्तव में इसके साथ काम मिला है?) वैसे भी, अब मैं ExecutorServiceइन कार्यों के लिए उपयोग करना पसंद करूंगा । यह वास्तव में पारंपरिक थ्रेड एपीआई पर एक बड़ा सुधार है। बस जवाब देने के समय इसका इस्तेमाल नहीं किया।

— रोहित जैन

Timer timer = new Timer(true);trueबहरे के रूप में सेट किया जाना चाहिए । जब तक आप एप्लिकेशन को बंद करने के बाद भी टाइमर चलाना चाहते हैं।

— टॉमाज़ मूलार्केज

इसने मुझे अंतत: मुझे टाइमर समझने में मदद की। + 1. अच्छा काम करो!

— डेनियल टॉर्क

Answer 2

यदि आप एक आवधिक कार्य करना चाहते हैं, तो एक का उपयोग करें ScheduledExecutorService। विशेष रूप से ScheduledExecutorService.scheduleAtFixedRate

कोड:

Runnable helloRunnable = new Runnable() {
    public void run() {
        System.out.println("Hello world");
    }
};

ScheduledExecutorService executor = Executors.newScheduledThreadPool(1);
executor.scheduleAtFixedRate(helloRunnable, 0, 3, TimeUnit.SECONDS);

Comments

मुझे आशा है कि किसी और ने भी इसे उकेरा। Thread.sleep () ओपी में कोड को सबसे अच्छी तरह से फिट कर सकता है, लेकिन यह पहिया के बजाय शौकिया सुदृढीकरण है। पेशेवर सॉफ्टवेयर इंजीनियर कोशिश और विश्वसनीय एपीआई का उपयोग करेंगे, जैसे कि टिमरस्क। ScheduledExecutorService भी बेहतर है, हालांकि; प्रैक्टिस में ब्रायन गोएट्ज एट अल के जावा कंजेरिबिलिटी का संदर्भ लें । उत्तरार्द्ध वर्ग लगभग एक दशक से है - यह दुखद है कि ये सभी अन्य उत्तर इसे अनदेखा करते हैं।

— माइकल स्काइपर

@MichaelScheper, धन्यवाद, मुझे यह देखकर खुशी हुई कि यह जवाब आखिरकार TimerTaskवेरिएंट को पार कर गया । दिलचस्प बात यह है कि मैंने देखा कि स्वीकृत उत्तर वास्तव में सही नहीं है: \ _ दो एपीआई की उम्र अलग-अलग है, ScheduledExecutorServiceबस अधिक सहज ज्ञान युक्त घोषणा है। TimeUnitएक पैरामीटर के रूप में उपयोग यह बहुत अधिक स्पष्ट करता है कि क्या हो रहा है। जैसे कोड के दिन गए हैं 5*60*1000 // 5 minutes।

— टिम बेंडर

@TimBender मैंने देखा कि आपके पास अवधि तर्क के लिए 3 है। मुझे नहीं पता कि यह सेकंड या मिलीसेकंड में है या नहीं। मैं इसे हर 500 मिलीसेकंड (आधा सेकंड) चलाना चाहूंगा।

— जॉनमेरिनो

हाँ! मैंने देखा। चौथा तर्क आपको समय निर्दिष्ट करने देता है जैसे TimeUnit.MILLISECONDS।

— जॉनमेरिनो

@TerryCarter Java8 में + इसके बजाय आप ऐसा कर सकते हैं Runnable helloRunnable = () -> { /*code */ };जो और भी सुंदर हो;)

— जोएल

Answer 3

ऐसा करने का प्रयास करें:

Timer t = new Timer();
t.schedule(new TimerTask() {
    @Override
    public void run() {
       System.out.println("Hello World");
    }
}, 0, 5000);

यह कोड हर 5000 मिलीसेकंड ( 5 सेकंड) पर हैलो वर्ल्ड को कंसोल करने के लिए प्रिंट चलाएगा । अधिक जानकारी के लिए, https://docs.oracle.com/javase/1.5.0/docs/api/java/util/Timer.html पढ़ें

Answer 4

मैं इसे एक टाइमर के साथ समझ रहा हूं, आशा है कि यह मदद करता है। मैंने एक ही पैकेज से java.util.Timerऔर एक टाइमर का उपयोग किया है TimerTask। निचे देखो:

TimerTask task = new TimerTask() {

    @Override
    public void run() {
        System.out.println("Hello World");
    }
};

Timer timer = new Timer();
timer.schedule(task, new Date(), 3000);

Answer 5

आप Thread.sleep(3000)लूप के लिए अंदर का उपयोग कर सकते हैं ।

नोट: इसके लिए एक try/catchब्लॉक की आवश्यकता होगी ।

Answer 6

public class HelloWorld extends TimerTask{

    public void run() {

        System.out.println("Hello World");
    }
}


public class PrintHelloWorld {
    public static void main(String[] args) {
        Timer timer = new Timer();
        timer.schedule(new HelloWorld(), 0, 5000);

        while (true) {
            try {
                Thread.sleep(2000);
            } catch (InterruptedException e) {
                System.out.println("InterruptedException Exception" + e.getMessage());
            }
        }
    }
}

अनंत लूप बनाया जाता है विज्ञापन शेड्यूलर कार्य कॉन्फ़िगर किया गया है।

Answer 7

सबसे आसान तरीका मुख्य धागा को सोने के लिए 3000 मिलीसेकंड (3 सेकंड) सेट करना होगा:

for(int i = 0; i< 10; i++) {
    try {
        //sending the actual Thread of execution to sleep X milliseconds
        Thread.sleep(3000);
    } catch(InterruptedException ie) {}
    System.out.println("Hello world!"):
}

यह थ्रेड को कम से कम X मिलीसेकंड पर रोक देगा। धागा अधिक समय तक सो सकता है, लेकिन यह जेवीएम तक है। केवल एक चीज की गारंटी है कि धागा कम से कम उन मिलीसेकंड को सोएगा। Thread#sleepडॉक्टर पर एक नज़र डालें :

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

Comments

धन्यवाद @ लुइगी। जावा हमेशा यह सुनिश्चित करेगा कि यह 3000 ms है चाहे मैं किसी भी मशीन (CPU) को सही पर चलाऊं?

— मीरियो

@ NandkumarTekale अधिक विस्तृत देखभाल करने के लिए?

— मीरियो

@meiryo यह कम से कम X मिलीसेकंड पर थ्रेड को रोक देगा। धागा अधिक समय तक सो सकता है, लेकिन यह जेवीएम तक है। केवल एक चीज की गारंटी है कि धागा कम से कम उन मिलीसेकंड को सोएगा।

— लुइगी मेंडोज़ा

कैविएट: यदि यह एक वास्तविक समय प्रणाली नहीं है, तो नींद कम से कम 3000 एमएस होगी, लेकिन अधिक समय तक हो सकती है। यदि आप वास्तव में 3000 एमएस नींद चाहते हैं, जहां मानव जीवन जोखिम में है (चिकित्सा उपकरण, विमानों को नियंत्रित करना आदि) तो आपको एक वास्तविक समय ऑपरेटिंग सिस्टम का उपयोग करना चाहिए।

— किंजल दीक्षित

@meiryo: लुइगी और किंजल ने बहुत अच्छे से समझाया :)

— नंदकुमार टेकले १६'१२

Answer 8

उपयोग java.util.Timerऔर Timer#schedule(TimerTask,delay,period)विधि आपकी मदद करेगी।

public class RemindTask extends TimerTask {
    public void run() {
      System.out.println(" Hello World!");
    }
    public static void main(String[] args){
       Timer timer = new Timer();
       timer.schedule(new RemindTask(), 3000,3000);
    }
  }

Answer 9

यह जावा में धागे का उपयोग करने का सरल तरीका है:

for(int i = 0; i< 10; i++) {
    try {
        //sending the actual Thread of execution to sleep X milliseconds
        Thread.sleep(3000);
    } catch(Exception e) {
        System.out.println("Exception : "+e.getMessage());
    }
    System.out.println("Hello world!");
}

Answer 10

उसने क्या क़हा। हालाँकि आप अपवादों को संभाल सकते हैं, लेकिन थ्रेड.सेलेप (मिलिसेकंड); लेने के लिए सबसे अच्छा मार्ग है।

public static void main(String[] args) throws InterruptedException {

Answer 11

यहाँ थ्रेड कंस्ट्रक्टर में रननेबल इंटरफ़ेस का उपयोग करने का एक और सरल तरीका है

public class Demo {
    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable() {

            @Override
            public void run() {
                for(int i = 0; i < 5; i++){
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("Thread T1 : "+i);
                }
            }
        });

        Thread t2 = new Thread(new Runnable() {

            @Override
            public void run() {
                for(int i = 0; i < 5; i++) {
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("Thread T2 : "+i);
                }
            }
        });

        Thread t3 = new Thread(new Runnable() {

            @Override
            public void run() {
                for(int i = 0; i < 5; i++){
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                    System.out.println("Thread T3 : "+i);
                }
            }
        });

        t1.start();
        t2.start();
        t3.start();
    }
}

Answer 12

जोड़ना Thread.sleep

try {
        Thread.sleep(3000);
    } catch(InterruptedException ie) {}

Answer 13

छोटे अनुप्रयोगों के लिए टाइमर और टाइमर का उपयोग करना ठीक है जैसा कि रोहित ने उल्लेख किया है, लेकिन वेब अनुप्रयोगों में मैं नौकरियों को शेड्यूल करने और इस तरह की आवधिक नौकरियों के लिए क्वार्ट्ज शेड्यूलर का उपयोग करूंगा ।

क्वार्ट्ज शेड्यूलिंग के लिए ट्यूटोरियल देखें ।

Answer 14

public class TimeDelay{
  public static void main(String args[]) {
    try {
      while (true) {
        System.out.println(new String("Hello world"));
        Thread.sleep(3 * 1000); // every 3 seconds
      }
    } catch (InterruptedException e) {
      e.printStackTrace();
    }
  }
}