मुझे थ्रेड का उपयोग करते समय अपवाद मिलता है। सो (x) या प्रतीक्षा ()

Question

मैंने विलंब करने की कोशिश की है - या सोने के लिए डाल दिया है - मेरा जावा प्रोग्राम, लेकिन एक त्रुटि होती है।

मैं उपयोग करने में असमर्थ हूं Thread.sleep(x)या wait()। एक ही त्रुटि संदेश प्रकट होता है:

अप्रमाणित अपवाद java.lang.InterruptedException; पकड़ा जाना चाहिए या फेंक दिया जाना चाहिए।

Thread.sleep()या wait()विधियों का उपयोग करने से पहले किसी भी कदम की आवश्यकता है ?

Comments

खैर, यह लोकप्रिय है। ऐसे लोगों की संख्या बहुत अधिक होनी चाहिए जिन्हें कुछ सेकंड के लिए अपने जावा प्रोग्राम में देरी करने की आवश्यकता होती है। कल्पना करना मुश्किल है। बेशक, सही शीर्षक को पोस्ट पर रखने से बहुत मदद मिलेगी।

— रॉबर्ट हार्वे

Answer 1

आपके आगे बहुत कुछ पढ़ने को है। संकलक हैंडलिंग, थ्रेडिंग और थ्रेड रुकावट के माध्यम से संकलक त्रुटियों से। लेकिन यह वही करेगा जो आप चाहते हैं:

try {
    Thread.sleep(1000);                 //1000 milliseconds is one second.
} catch(InterruptedException ex) {
    Thread.currentThread().interrupt();
}

Comments

आपकी मदद के लिए धन्यवाद, मैं इसे चलाने में सक्षम हूं .. बगल में, पकड़ने के लिए क्या उपयोग है (बाधित पूर्व

— अपवाद

हाबिल से जवाब देखें। InterruptedException के लिए Google। एक लंबी कहानी को छोटा बनाना: सोते समय धागे को बाधित किया जा सकता है, और यह एक प्रकार का अपवाद है जिसे स्पष्ट रूप से नियंत्रित करने की आवश्यकता है।

— कोनराड गेरूस

कुछ जवाब अपवाद पर कुछ नहीं करने के लिए कहते हैं, कुछ फेंकने के लिए कहते हैं, यह व्यवधान () को बताता है। क्या कोई चर्चा करने के लिए परवाह करेगा कि कौन सा उपयुक्त है और क्यों?

— सुमा

@ सुमा इस पर बहुत चर्चा करता है, जिसमें स्टैक ओवरफ्लो भी शामिल है। बस इसे खोजो। एक टिप्पणी के लिए बहुत लंबा है। कुछ वर्षों के बाद, मेरे पास एकमात्र उत्तर है: यह निर्भर करता है। आमतौर पर आदर्श समाधान यह है कि जो भी धागा इनायत से कर रहा है उसे समाप्त करें (जैसे इस लेन-देन को वापस करें, लूप को तोड़ें आदि), लेकिन यह एक संदर्भ पर निर्भर है।

— कोनराड गरुस

तो टाइमर किसके लिए है? क्या आप टाइमर के साथ समान कार्यक्षमता प्राप्त कर सकते हैं? मैंने जावा डॉक पढ़ा, और इसमें देरी के बारे में कुछ बताया, लेकिन कोड के साथ एक नौसिखिया होने के नाते, हाई स्कूल प्रोग्रामिंग के अपने दूसरे वर्ष को पूरा करने के बारे में im, मुझे पूरी तरह से यकीन नहीं है कि अगर देरी के बारे में बात करते हैं तो यह उपयोगी होगा, या यहां तक ​​कि। उपयोग करने का सही वर्ग

— Ungeheuer

Answer 2

जैसा कि अन्य उपयोगकर्ताओं ने कहा है कि आपको अपने कॉल को try{...} catch{...}ब्लॉक से घेरना चाहिए । लेकिन जब से जावा 1.5 जारी किया गया था, TimeUnit वर्ग है जो थ्रेड.स्लीप (मिली) के समान है, लेकिन अधिक सुविधाजनक है। आप नींद ऑपरेशन के लिए समय इकाई चुन सकते हैं।

try {
    TimeUnit.NANOSECONDS.sleep(100);
    TimeUnit.MICROSECONDS.sleep(100);
    TimeUnit.MILLISECONDS.sleep(100);
    TimeUnit.SECONDS.sleep(100);
    TimeUnit.MINUTES.sleep(100);
    TimeUnit.HOURS.sleep(100);
    TimeUnit.DAYS.sleep(100);
} catch (InterruptedException e) {
    //Handle exception
}

इसके अलावा इसके अतिरिक्त तरीके हैं: TimeUnit Oracle Documentation

Comments

आवश्यक try-catchअपवाद हैंडलिंग के साथ इन कॉल को कैसे घेरें, उदाहरण के लिए अन्य उत्तर देखें ।

— बेसिल बोर्क

मत भूलना "आयात java.util.concurrent.TimeUnit;"

— कोडर

Answer 3

इस उत्कृष्ट संक्षिप्त पोस्ट पर एक नज़र डालें कि यह कैसे ठीक से किया जाए।

अनिवार्य रूप से: पकड़ InterruptedException। याद रखें कि आपको इस कैच-ब्लॉक को जोड़ना होगा। पोस्ट इसे थोड़ा और समझाती है।

Answer 4

अपवादों को संभालने के लिए निम्न कोडिंग निर्माण का उपयोग करें

try {
  Thread.sleep(1000);
} catch (InterruptedException ie) {
    //Handle exception
}

Answer 5

Thread.sleepएक कोशिश पकड़ने ब्लॉक में अपने रखो

try {
    //thread to sleep for the specified number of milliseconds
    Thread.sleep(100);
} catch ( java.lang.InterruptedException ie) {
    System.out.println(ie);
}

Answer 6

एंड्रॉइड का उपयोग करते समय (केवल उसी समय जब मैं जावा का उपयोग करता हूं) मैं थ्रेड को सोने के बजाय हैंडलर का उपयोग करने की सलाह दूंगा।

final Handler handler = new Handler();
    handler.postDelayed(new Runnable() {
        @Override
        public void run() {
            Log.i(TAG, "I've waited for two hole seconds to show this!");

        }
    }, 2000);

संदर्भ: http://developer.android.com/reference/android/os/Handler.html

Comments

यह एंड्रॉइड के लिए है कोर जावा के लिए नहीं

— गणेश कृष्णन

Answer 7

इसे इस्तेमाल करे:

try{

    Thread.sleep(100);
}catch(Exception e)
{
   System.out.println("Exception caught");
}

Comments

यह Exceptionजावा में पकड़ने के लिए बुरा अभ्यास नहीं है ?

— माइकल डोरस्ट

अन्य उत्तरों की तरह इंटरप्टेडएक्ससेप्शन को बेहतर तरीके से पकड़ना

— devsaw

इसे 'पोकेमॉन एक्सेप्शन हैंडलर' कहा जाता है - जो सभी को पसंद आएगा।

— जेम्स टायलर

Answer 8

जावा प्रोग्राम में देरी को जोड़ने के मेरे तरीके।

public void pause1(long sleeptime) {
    try {
        Thread.sleep(sleeptime);
    } catch (InterruptedException ex) {
        //ToCatchOrNot
    }
}

public void pause2(long sleeptime) {
    Object obj = new Object();
    if (sleeptime > 0) {
        synchronized (obj) {
            try {
                obj.wait(sleeptime);
            } catch (InterruptedException ex) {
                //ToCatchOrNot
            }
        }
    }
}
public void pause3(long sleeptime) {
    expectedtime = System.currentTimeMillis() + sleeptime;
    while (System.currentTimeMillis() < expectedtime) {
        //Empty Loop   
    }
}

यह अनुक्रमिक देरी के लिए है लेकिन लूप देरी के लिए जावा विलंब / प्रतीक्षा को देखें ।

Comments

कृपया ध्यान दें कि यहाँ पर स्व-प्रचार की अनुमति नहीं है। हेल्प सेंटर का अंतिम बिंदु यहां देखें । हालाँकि, आप अपनी प्रोफ़ाइल में लिंक डाल सकते हैं - जिसकी अनुमति है।

— एसएल बार्थ -

Answer 9

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


  short z=1000;
  Thread.sleep(z);/*will provide 1 second delay. alter data type of z or value of z for longer delays required */

  //type code
}

जैसे: -

class TypeCasting {

  public static void main(String[] args) throws InterruptedException {
    short f = 1;
    int a = 123687889;
    short b = 2;
    long c = 4567;
    long d=45;
    short z=1000;
    System.out.println("Value of a,b and c are\n" + a + "\n" + b + "\n" + c + "respectively");
    c = a;
    b = (short) c;
    System.out.println("Typecasting...........");
    Thread.sleep(z);
    System.out.println("Value of B after Typecasting" + b);
    System.out.println("Value of A is" + a);


  }
}

Answer 10

प्रतीक्षा करने का एक सरल तरीका उपयोग करना है System.currentTimeMillis(), जो 1 जनवरी, 1970 यूटीसी पर आधी रात के बाद से मिलीसेकंड की संख्या देता है। उदाहरण के लिए, 5 सेकंड प्रतीक्षा करने के लिए:

public static void main(String[] args) {
    //some code
    long original = System.currentTimeMillis();
    while (true) {
        if (System.currentTimeMillis - original >= 5000) {
            break;
        }
    }
    //more code after waiting
}

इस तरह, आपको थ्रेड्स और अपवादों के बारे में नहीं सोचना चाहिए। उम्मीद है की यह मदद करेगा!

Comments

यह प्रतीक्षा करते समय सीपीयू का उपभोग करता है।

— yacc

@ येक यह सच है, लेकिन यह थ्रेड्स का उपयोग करने की तुलना में सरल है और बहुत अधिक सीपीयू का उपयोग नहीं करता है।

— सैम

Answer 11

उपयोग करें java.util.concurrent.TimeUnit:

TimeUnit.SECONDS.sleep(1);

एक सेकंड के लिए सो जाओ या

TimeUnit.MINUTES.sleep(1);

एक मिनट के लिए सो जाओ।

जैसा कि यह एक लूप है, यह एक अंतर्निहित समस्या प्रस्तुत करता है - बहाव। हर बार जब आप कोड चलाते हैं और फिर सोते हैं तो आप दौड़ने से थोड़ा हटकर कहेंगे, हर सेकंड। यदि यह एक समस्या है तो उपयोग न करें sleep।

इसके अलावा, sleepबहुत लचीला नहीं है जब यह नियंत्रण में आता है।

किसी कार्य को हर सेकंड या एक सेकंड की देरी से चलाने के लिए, मैं दृढ़ता से एक [ ScheduledExecutorService] [१] और या तो [ scheduleAtFixedRate] [२] या [] की सिफारिश करूँगाscheduleWithFixedDelay ] [३] की ।

विधि को myTaskहर सेकंड (जावा 8) चलाने के लिए :

public static void main(String[] args) {
    final ScheduledExecutorService executorService = Executors.newSingleThreadScheduledExecutor();
    executorService.scheduleAtFixedRate(App::myTask, 0, 1, TimeUnit.SECONDS);
}

private static void myTask() {
    System.out.println("Running");
}

Answer 12

Thread.sleep() शुरुआती लोगों के लिए सरल है और अवधारणा के यूनिट परीक्षणों और सबूतों के लिए उपयुक्त हो सकता है।

लेकिन कृपया उत्पादन कोड के लिए उपयोग न करें sleep()। आखिरकार sleep()आपको बुरी तरह से काट सकता है।

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

नीचे दिया गया कोड उस तकनीक को प्रदर्शित करता है:

import java.util.concurrent.TimeUnit;
public class DelaySample {
    public static void main(String[] args) {
       DelayUtil d = new DelayUtil();
       System.out.println("started:"+ new Date());
       d.delay(500);
       System.out.println("half second after:"+ new Date());
       d.delay(1, TimeUnit.MINUTES); 
       System.out.println("1 minute after:"+ new Date());
    }
}

DelayUtil कार्यान्वयन:

import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public class DelayUtil {
    /** 
    *  Delays the current thread execution. 
    *  The thread loses ownership of any monitors. 
    *  Quits immediately if the thread is interrupted
    *  
    * @param durationInMillis the time duration in milliseconds
    */
   public void delay(final long durationInMillis) {
      delay(durationInMillis, TimeUnit.MILLISECONDS);
   }

   /** 
    * @param duration the time duration in the given {@code sourceUnit}
    * @param unit
    */
    public void delay(final long duration, final TimeUnit unit) {
        long currentTime = System.currentTimeMillis();
        long deadline = currentTime+unit.toMillis(duration);
        ReentrantLock lock = new ReentrantLock();
        Condition waitCondition = lock.newCondition();

        while ((deadline-currentTime)>0) {
            try {
                lock.lockInterruptibly();    
                waitCondition.await(deadline-currentTime, TimeUnit.MILLISECONDS);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return;
            } finally {
                lock.unlock();
            }
            currentTime = System.currentTimeMillis();
        }
    }
}

Answer 13

वैकल्पिक रूप से, यदि आप थ्रेड्स से निपटना नहीं चाहते हैं, तो इस विधि को आजमाएँ:

public static void pause(int seconds){
    Date start = new Date();
    Date end = new Date();
    while(end.getTime() - start.getTime() < seconds * 1000){
        end = new Date();
    }
}

यह तब शुरू होता है जब आप इसे कॉल करते हैं, और तब समाप्त होता है जब सेकंड की संख्या बीत चुकी होती है।

Comments

यह सोने के समय में सीपीयू का उपभोग करेगा। Thread.sleep () पर धागे को डिसाइड किया जा सकता है।

— विवेक पांडे

आप रिडी हैं और पानी नहीं है: D

— M410

user2276378 ने प्रश्न की अंग्रेजी को गलत समझा था। ओपी ने कहा कि वह "नींद या प्रतीक्षा में असमर्थ" था, जिसे user2276378 ने सोचा था कि वह उनका उपयोग नहीं कर सकता (या उन्हें उपयोग करने की अनुमति नहीं थी) और इसलिए उसने एक वैध समाधान प्रदान किया जिसमें नींद या प्रतीक्षा का उपयोग नहीं किया गया था। कोशिश करें कि बहुत कठोर न बनें अंग्रेजी हर किसी की पहली भाषा नहीं है।

— डेविड न्यूकोम्ब