java - অপেক্ষা () এবং ঘুম () মধ্যে পার্থক্য

multithreading sleep java-threads (25)

ঘুম / বিরতি এবং অপেক্ষা / অবহিত মধ্যে একটি সম্ভাব্য বড় পার্থক্য যে

কলিং t.interrupt() Thread.sleep() সময় Thread.sleep() সর্বদা একটি ব্যতিক্রম ছোঁড়ে (যেমন, InterruptedException )
কলিং notify wait() সময় wait() না।

প্রয়োজন নেই যখন একটি ব্যতিক্রম উৎপন্ন অক্ষম। আপনার যদি উচ্চ হারে একে অপরের সাথে যোগাযোগের থ্রেড থাকে, তবে আপনি যদি সর্বদা বিঘ্নিত কল করে থাকেন তবে এটি CPU এর মোট অপচয়।

থ্রেডে wait() এবং sleep() মধ্যে পার্থক্য কী?

আমার বোঝার যে একটি wait() -র থ্রেড এখনও চলমান মোডে চলছে এবং CPU চক্র ব্যবহার করে কিন্তু একটি sleep() -ইং কোন CPU চক্রগুলি সঠিকভাবে গ্রাস করে না?

কেন আমরা উভয় wait() এবং sleep() : তাদের বাস্তবায়ন একটি নিম্ন স্তরে কিভাবে পরিবর্তিত হয়?

অপেক্ষাটি অন্য থ্রেড দ্বারা "জাঙ্ক আপ" হতে পারে যা নিরীক্ষণের জন্য অপেক্ষা করা মনিটরকে notify করে যখন sleep না পারে। এছাড়াও wait (এবং notify ) মনিটর বস্তুর সাথে synchronized হওয়া একটি ব্লকের মধ্যে ঘটতে হবে তবে sleep হয় না:

Object mon = ...;
synchronized (mon) {
    mon.wait();
}

এই মুহুর্তে বর্তমানে এক্সিকিউটিভ থ্রেড অপেক্ষা এবং মনিটর মুক্তি । অন্য থ্রেড করতে পারে

synchronized (mon) { mon.notify(); }

(একই mon বস্তুতে) এবং প্রথম থ্রেড (মনিটরিংয়ের অপেক্ষা করা একমাত্র থ্রেড অনুমান করা) জাগবে।

আপনি যদি একাধিক থ্রেড মনিটর অপেক্ষা করে থাকেন তবে এটি notifyAll পারেন - এটি তাদের সকলকে জাগিয়ে তুলবে। যাইহোক, শুধুমাত্র থ্রেডগুলির মধ্যে একটি মনিটর দখল করতে সক্ষম হবে (মনে রাখবেন যে synchronized একটি synchronized ব্লকে রয়েছে) এবং চালিয়ে যান - অন্যরা তখন মনিটর এর লক অর্জন না করা পর্যন্ত অবরুদ্ধ থাকবে।

আরেকটি বিষয় হল আপনি Object উপর wait করুন (অর্থাত আপনি একটি বস্তুর মনিটর অপেক্ষা করুন) যখন আপনি Thread ।

তবুও আরেকটি বিষয় হল যে আপনি wait থেকে জঘন্য wakeups পেতে পারেন (অর্থাত থ্রেড যা কোন প্রত্যক্ষ কারণে অপেক্ষা করছে)। নিম্নরূপ: আপনি কিছু শর্তে কাঁপন যখন সবসময় wait উচিত:

synchronized {
    while (!condition) { mon.wait(); }
}

আমার মতে, উভয় পদ্ধতির মধ্যে প্রধান পার্থক্য হলো ঘুম / বাধাগুলি থ্রেডগুলিকে পরিচালনা করার সবচেয়ে মৌলিক উপায়, যখন অপেক্ষা / বিজ্ঞপ্তিটি থ্রেড আন্তঃযোগাযোগ সহজতর করার লক্ষ্যে একটি বিমূর্ততা। এর মানে হল ঘুম / ব্যবধান কিছু করতে পারে, কিন্তু এই নির্দিষ্ট কাজটি করা কঠিন।

কেন অপেক্ষা / আরো উপযুক্ত অবহিত করা হয়? এখানে কিছু ব্যক্তিগত বিবেচনার বিষয় রয়েছে:

এটা কেন্দ্রীকরণ প্রয়োগ। এটি একটি একক ভাগ করা বস্তুর সাথে থ্রেডগুলির একটি গোষ্ঠীর মধ্যে যোগাযোগ সমন্বয় করার অনুমতি দেয়। এই কাজ অনেক সহজ।
এটি সিঙ্ক্রোনাইজেশন প্রয়োগ করে। কারণ এটি প্রোগ্রামারটিকে সিঙ্ক্রোনাইজড ব্লকটিতে অপেক্ষা / অবহিত করার জন্য কলটি মোড়ানো করে।
এটি থ্রেড উৎপত্তি এবং সংখ্যা থেকে স্বাধীন। এই পদ্ধতির সাথে আপনি অন্য থ্রেডগুলি সম্পাদনা না করে বা বিদ্যমানগুলির একটি ট্র্যাক রেখেও ইচ্ছাকৃতভাবে আরো থ্রেড যোগ করতে পারেন। আপনি যদি ঘুম / ব্যাঘাত ব্যবহার করেন তবে প্রথমে আপনাকে ঘুমের থ্রেডগুলিতে রেফারেন্সগুলি রাখতে হবে এবং তারপরে হাত দিয়ে একে অপরকে ব্যাহত করতে হবে।

বাস্তব জীবনের একটি উদাহরণ যা ব্যাখ্যা করা ভাল তা হল একটি ক্লাসিক রেস্তোরাঁ এবং কর্মচারী তাদের মধ্যে যোগাযোগ করার পদ্ধতিটি ব্যবহার করে: ওয়েটাররা গ্রাহকের অনুরোধগুলি কেন্দ্রীয় স্থানে ছেড়ে দেয় (একটি কর্ক বোর্ড, একটি টেবিল, ইত্যাদি), একটি ঘণ্টা রিং, এবং রান্নাঘর থেকে কর্মীদের যেমন অনুরোধ নিতে আসে। একবার যে কোন কোর্স প্রস্তুত হলে, রান্নাঘর কর্মীরা আবার ঘণ্টাটি রিং করে যাতে ওয়েটাররা সচেতন হয় এবং গ্রাহকদের কাছে নিয়ে যায়।

ঘুম () হল একটি পদ্ধতি যা কয়েক সেকেন্ডের জন্য বা আপনার চাওয়া সময়ের জন্য প্রক্রিয়াটি ধরে রাখার জন্য ব্যবহৃত হয় তবে অপেক্ষা করার ক্ষেত্রে () পদ্ধতি থ্রেডটি অপেক্ষা অবস্থায় চলে যায় এবং এটি স্বয়ংক্রিয়ভাবে ফিরে আসবে না যতক্ষণ না আমরা অবহিত () বা notifyAll ()।

প্রধান পার্থক্য হল যে অপেক্ষা () ঘুমের সময় লক বা মনিটরটি ছেড়ে দেয় () অপেক্ষা করার সময় কোনও লক বা মনিটর প্রকাশ করে না। ঘুমানোর সময় আন্তঃ-থ্রেড যোগাযোগের জন্য অপেক্ষা করা হয় যখন ঘুমটি সাধারণত সঞ্চালনের জন্য বিরতি প্রবর্তন করতে ব্যবহৃত হয়।

Thread.sleep () কিছু সময়ের জন্য বর্তমান থ্রেডটিকে "না চালানোর যোগ্য" অবস্থায় প্রেরণ করে। থ্রেড এটি অর্জিত মনিটর রাখে - অর্থাৎ যদি থ্রেড বর্তমানে একটি সিঙ্ক্রোনাইজড ব্লক বা পদ্ধতিতে থাকে তবে অন্য কোন থ্রেড এই ব্লক বা পদ্ধতিতে প্রবেশ করতে পারবে না। যদি অন্য থ্রেড t.interrupt () কে কল করে তবে ঘুমন্ত থ্রেডটি ঘুম থেকে উঠবে। মনে রাখবেন ঘুম একটি স্ট্যাটিক পদ্ধতি, যার মানে এটি সর্বদা বর্তমান থ্রেডকে প্রভাবিত করে (যেটি ঘুম পদ্ধতিটি কার্যকর করছে)। একটি সাধারণ ভুল হল t.sleep () কল যেখানে t একটি ভিন্ন থ্রেড হয়; তবুও, এটি বর্তমান থ্রেড যা ঘুমিয়ে থাকবে, টি থ্রেড নয়।

object.wait () বর্তমান থ্রেডকে "নন রান্নেবল" অবস্থায় ঘুমানো (), কিন্তু একটি মোড়ক দিয়ে প্রেরণ করে। অপেক্ষা একটি বস্তুর উপর বলা হয়, একটি থ্রেড নয়; আমরা এই বস্তুর "লক অবজেক্ট" কল করি। lock.wait () বলা হয়, বর্তমান থ্রেডটি লক অবজেক্টে সিঙ্ক্রোনাইজ করতে হবে; অপেক্ষা করুন () তারপর এই লকটি রিলিজ করে এবং লকের সাথে সংযুক্ত "অপেক্ষা তালিকা" তে থ্রেড যোগ করে। পরে, অন্য থ্রেড একই লক অবজেক্টে সিঙ্ক্রোনাইজ করতে পারে এবং lock.notify () কে কল করতে পারে। এই মূল, অপেক্ষা থ্রেড জেগে ওঠে। মূলত, অপেক্ষা করুন () / অবহিত করুন () ঘুমের মত () / বাধা (), শুধুমাত্র সক্রিয় থ্রেডটিকে ঘুমন্ত থ্রেডে সরাসরি পয়েন্টারের প্রয়োজন নেই, তবে শুধুমাত্র ভাগ করা লক বস্তুতে।

synchronized(LOCK) {   
   Thread.sleep(1000); // LOCK is held
}

synchronized(LOCK) {   
   LOCK.wait(); // LOCK is not held
}

উপরের সব পয়েন্ট শ্রেণীভুক্ত করা যাক:

Call on:

অপেক্ষা করুন (): একটি বস্তুর উপর কল করুন; বর্তমান থ্রেড লক বস্তুর উপর সিঙ্ক্রোনাইজ করতে হবে।
ঘুম (): একটি থ্রেড উপর কল করুন; সবসময় বর্তমানে থ্রেড নির্বাহ।

Synchronized:

অপেক্ষা করুন (): যখন একাধিক থ্রেড সমলয় করা একই বস্তু এক এক একযোগে অ্যাক্সেস।
ঘুম (): একাধিক থ্রেড সিঙ্ক্রোনাইজ যখন ঘুমের থ্রেড উপর ঘুমের জন্য অপেক্ষা করুন।

Hold lock:

অপেক্ষা করুন (): অন্য বস্তুর জন্য লকটি কার্যকর করার সুযোগটি ছেড়ে দিন।
ঘুম (): টাইমআউট নির্দিষ্ট বা কেউ বাধা দেয় যদি অন্তত টি বার জন্য লক রাখা।

Wake-up condition:

অপেক্ষা করুন (): কলটি অবহিত না হওয়া পর্যন্ত (), অবহিত করুন অল ()
ঘুম (): অন্তত সময় মেয়াদ শেষ না হওয়া পর্যন্ত বা কলটি বাধা দেয় ()।

Usage:

ঘুম (): সময়-সিঙ্ক্রোনাইজেশন এবং জন্য;
অপেক্ষা করুন (): মাল্টি-থ্রেড-সিঙ্ক্রোনাইজেশনের জন্য।

রেফারেন্স: sleep এবং wait

sleep Thread একটি পদ্ধতি, Object একটি পদ্ধতি, তাই wait/notify জাভাতে ( monitor ব্যবহার করে) ভাগ করা ডেটা সিঙ্ক্রোনাইজ করার একটি কৌশল, তবে sleep নিজেকে থামাতে থ্রেডের একটি সহজ পদ্ধতি।

এখানে অপেক্ষা করুন () অপেক্ষারত অবস্থায় থাকবে যখন এটি অন্য থ্রেড দ্বারা সূচিত না হয় তবে ঘুমের মধ্যে কিছু সময় থাকবে .. তারপরে এটি স্বয়ংক্রিয়ভাবে প্রস্তুত অবস্থায় স্থানান্তরিত হবে ...

এখানে, আমি wait() এবং sleep() পদ্ধতিগুলির মধ্যে কয়েকটি গুরুত্বপূর্ণ পার্থক্য তালিকাভুক্ত করেছি।
পিএস: লাইব্রেরী কোড দেখার জন্য লিঙ্কগুলিতে ক্লিক করুন (অভ্যন্তরীণ কাজ, ভাল বোঝার জন্য কেবল একটু বেশি খেলুন)।

wait()

wait() পদ্ধতি লক রিলিজ।
wait() Object ক্লাসের পদ্ধতি।
wait() অ স্ট্যাটিক পদ্ধতি - public final void wait() throws InterruptedException { //...}
wait() notify() বা notify() notifyAll() পদ্ধতি দ্বারা notify() করা উচিত।
মিথ্যা এলার্ম মোকাবেলা করার জন্য wait() পদ্ধতিটি একটি লুপ থেকে বলা দরকার।
wait() পদ্ধতিটি সিঙ্ক্রোনাইজড প্রসঙ্গ (যেমন সিঙ্ক্রোনাইজড পদ্ধতি বা ব্লক) থেকে আহ্বান করা উচিত, নাহলে এটি IllegalMonitorStateException নিক্ষেপ IllegalMonitorStateException

sleep()

sleep() পদ্ধতি লক মুক্তি না।
sleep() java.lang.Thread । java.lang.Thread ক্লাসের পদ্ধতি।
sleep() স্ট্যাটিক পদ্ধতি - public static void sleep(long millis, int nanos) throws InterruptedException { //... }
নির্দিষ্ট পরিমাণ সময় পরে, sleep() সম্পন্ন হয়।
sleep() লুপ থেকে কল না ভাল (অর্থাত্ নীচের কোড দেখুন )।
sleep() কোথাও থেকে বলা যেতে পারে। কোন নির্দিষ্ট প্রয়োজন নেই।

রেফারেন্স: অপেক্ষা এবং ঘুমের মধ্যে পার্থক্য

অপেক্ষা এবং ঘুম পদ্ধতি কলিং জন্য কোড স্নিপেট

synchronized(monitor){
    while(condition == true){ 
        monitor.wait()  //releases monitor lock
    }

    Thread.sleep(100); //puts current thread on Sleep    
}

আপনি সঠিক - ঘুমের কারণটি "ঘুম" এবং CPU টি বন্ধ করে এবং অন্যান্য থ্রেডগুলি প্রক্রিয়া করতে পারে (অন্যথা কনটেক্সট স্যুইচিং হিসাবে পরিচিত) wheras আমি বিশ্বাস করি অপেক্ষা করুন CPU টি বর্তমান থ্রেডটি প্রক্রিয়াকরণ করে রাখে।

আমাদের উভয়ই আছে যদিও এটির ব্যবহার না করে অন্য লোকেদের CPU ব্যবহার করার জন্য এটি বোধগম্য বলে মনে হতে পারে তবে প্রকৃতপক্ষে প্রসঙ্গ সুইচিংয়ের উপরে ওভারহেড রয়েছে - ঘুমের জন্য কতক্ষণ এটি নির্ভর করে, এটি CPU চক্রগুলিতে আরও ব্যয়বহুল হতে পারে তুলনায় থ্রেড সুইচ কেবল আপনার থ্রেড কিছু ms জন্য কিছুই করছেন না।

এছাড়াও ঘুম শক্তি একটি প্রসঙ্গ সুইচ নোট করুন।

এছাড়াও - সাধারণভাবে কনটেক্সট স্যুইচিং নিয়ন্ত্রণ করা সম্ভব নয় - অপেক্ষার সময় ওএস অপেক্ষা করতে পারে (এবং অপেক্ষা করতে থাকবে) অন্যান্য থ্রেডগুলি প্রক্রিয়া করতে পছন্দ করে।

একটি কী পার্থক্য এখনও উল্লেখ করা হয় না যে একটি থ্রেড ঘুমানোর সময় এটি বন্ধ থাকা লকগুলি ছেড়ে দেয় না , অপেক্ষার সময় অপেক্ষারত বস্তুর উপর লক প্রকাশ করে wait() বলা হয়।

synchronized(LOCK) {
    Thread.sleep(1000); // LOCK is held
}


synchronized(LOCK) {
    LOCK.wait(); // LOCK is not held
}

পদ্ধতি বিভিন্ন জিনিস জন্য ব্যবহার করা হয়।

Thread.sleep(5000);   // Wait until the time has passed.

Object.wait();        // Wait until some other thread tells me to wake up.

Thread.sleep (n) বাধাগ্রস্ত হতে পারে, কিন্তু Object.wait () অবশ্যই অবহিত করা আবশ্যক । অপেক্ষা করার জন্য সর্বাধিক সময় উল্লেখ করা সম্ভব: Object.wait(5000)সুতরাং wait, er ব্যবহার করা সম্ভব হবে , sleepকিন্তু তারপরে আপনাকে তালা দিয়ে বিরক্ত করতে হবে।

ঘুমের / অপেক্ষার সময় পদ্ধতিগুলির মধ্যে কোনটি cpu ব্যবহার করে না।

পদ্ধতিগুলি অনুরূপ গঠনগুলি ব্যবহার করে, একইভাবে নয়, নেটিভ কোড ব্যবহার করে প্রয়োগ করা হয়।

নিজের জন্য দেখুন: স্থানীয় পদ্ধতির উত্স কোড উপলব্ধ? ফাইল /src/share/vm/prims/jvm.cppশুরু বিন্দু ...

অপেক্ষা করুন () এবং ঘুম () পার্থক্য?

Thread.sleep () তার কাজ সম্পন্ন হলে শুধুমাত্র এটি প্রত্যেকের জন্য লক প্রকাশ। তার কখনও লক মুক্তি না হওয়া পর্যন্ত।

  Sleep() take the key, its never release the key to anyone, when its work completed then only its release then only take the key waiting stage threads.

Object.wait () যখন এটি পর্যায় অপেক্ষা করতে যাচ্ছে, তখন এটি কীটি ছেড়ে দেওয়া হবে এবং তারপরে কয়েক সেকেন্ডের জন্য এটি প্যারামিটারের উপর অপেক্ষা করবে।

উদাহরণ স্বরূপ:

আপনি আপনার ডানদিকে কফি গ্রহণ করেন, আপনি একই হাত থেকে অন্য কাউকে নিতে পারেন, যখন আপনি ঢুকে পড়বেন তখন অন্য বস্তুটি এখানে একই রকম করে নেবেন। এছাড়াও। এই ঘুম হয় () তুমি ঘুমানোর সময় তুমি কোন কাজ করনি, তুমি শুধু ঘুমাচ্ছো ... এখানেও একই।

অপেক্ষা করুন ()। যখন আপনি নিচে রাখা এবং অপেক্ষার সময় অন্য একটি গড় নিতে, যে অপেক্ষা

আপনি প্লেয়ার হিসাবে আপনার সিস্টেমে বা অন্য কোনও প্লেয়ার প্লেয়ার হিসাবে একই সময়ে একাধিক না খেলতে পারেন, এটি এখানে, যখন আপনি বন্ধ করেন এবং অন্য কেউ যে কোনও চলচ্চিত্র বা গানের অর্থ নির্বাচন করেন তবে অপেক্ষা করা হয়

এই পোস্ট থেকে: http://javaconceptoftheday.com/difference-between-wait-and-sleep-methods-in-java/

অপেক্ষা করুন () পদ্ধতি।

1) থ্রেড যা অপেক্ষা () পদ্ধতি কল করে তা লকটি রিলিজ করে।

2) থ্রেড অন্যান্য থ্রেডের পরে লকটি আবার লক করে বা একই লকটিতে অবহিত () বা অবহিত All () পদ্ধতিগুলিকে কল করে।

3) অপেক্ষা () পদ্ধতি সিঙ্ক্রোনাইজড ব্লক মধ্যে বলা আবশ্যক।

4) অপেক্ষা () পদ্ধতি সবসময় বস্তু বলা হয়।

5) প্রতীক্ষা থ্রেডগুলিকে অবহিত () বা অবহিত All () পদ্ধতিগুলি কল করে অন্য থ্রেডগুলি দ্বারা জাগ্রত করা যেতে পারে।

6) অপেক্ষা () পদ্ধতি কল করার জন্য, থ্রেডে বস্তুর লক থাকতে হবে।

ঘুম () পদ্ধতি

1) নিদ্রা () পদ্ধতিটি যে থ্রেডটি ধারণ করে তা লকটি ছেড়ে দেয় না।

2) ঘুম () পদ্ধতি সিঙ্ক্রোনাইজড ব্লকের ভিতরে বা বাইরে বলা যেতে পারে।

3) ঘুম () পদ্ধতি সবসময় থ্রেড বলা হয়।

4) ঘুমন্ত থ্রেড অন্য থ্রেড দ্বারা জাগ্রত করা যাবে না। যদি তাই হয়, থ্রেড InterruptedException নিক্ষেপ করা হবে।

5) ঘুম () পদ্ধতিতে কল করার জন্য থ্রেডে বস্তুর লক থাকা দরকার না।

অ্যারাকাল ডকুমেন্টেশন পৃষ্ঠা থেকে wait() পদ্ধতি Object:

public final void wait()

বর্তমান থ্রেডটি অপেক্ষা করতে পারে যতক্ষণ না অন্য থ্রেড notify()পদ্ধতি বা notifyAll()এই বস্তুর জন্য পদ্ধতি আহ্বান করে । অন্য কথায়, এই পদ্ধতি ঠিক যেমনটি কেবল কলটি সম্পাদন করে ঠিক তেমন আচরণ করে wait(0)।
বর্তমান থ্রেড এই বস্তুর মনিটর মালিক থাকা আবশ্যক। থ্রেড এই মনিটারের মালিকানা প্রকাশ করে এবং অন্য থ্রেড জেগে ওঠার জন্য এই বস্তুর মনিটর অপেক্ষা থ্রেডগুলিকে সূচিত না হওয়া পর্যন্ত অপেক্ষা করে
হস্তক্ষেপ এবং জঘন্য wakeups সম্ভব
এই পদ্ধতিটি শুধুমাত্র একটি থ্রেড দ্বারা বলা উচিত যা এই বস্তুর মনিটরটির মালিক

এই পদ্ধতি ছুড়ে

IllegalMonitorStateException - বর্তমান থ্রেড বস্তুর মনিটর মালিক না।
InterruptedException- যদি কোন থ্রেড বর্তমান থ্রেডটি আগে বা যখন বর্তমান থ্রেডটি একটি বিজ্ঞপ্তিটির জন্য অপেক্ষা করছে তখন বাধা দেয়। এই ব্যতিক্রমটি নিক্ষেপ করা হলে বর্তমান থ্রেডের বাধাগ্রস্ত অবস্থাটি সাফ করা হয়।

অলাক্স ডকুমেন্টেশন পৃষ্ঠা থেকে sleep() পদ্ধতির Threadক্লাস:

public static void sleep(long millis)

নির্দিষ্ট সময়সীমার মিলিসেকেন্ডগুলির জন্য বর্তমানে নির্বাহিত থ্রেড ঘুমাতে (সাময়িকভাবে বিঘ্নিত হওয়া) কারণ, সিস্টেম টাইমার এবং সময় নির্ধারণকারীগুলির নির্ভুলতা এবং সঠিকতা সাপেক্ষে।
থ্রেড কোনো মনিটর মালিকানা হারান না।

এই পদ্ধতি ছুড়ে ফেলে:

IllegalArgumentException - মিলিস মান নেতিবাচক হয়
InterruptedException- যদি কোন থ্রেড বর্তমান থ্রেড বাধা দেয়। এই ব্যতিক্রমটি নিক্ষেপ করা হলে বর্তমান থ্রেডের বাধাগ্রস্ত অবস্থাটি সাফ করা হয়।

অন্যান্য কী পার্থক্য:

wait()স্ট্যাটিক পদ্ধতি sleep()(ক্লাস পদ্ধতি) অসদৃশ একটি অ স্ট্যাটিক পদ্ধতি (উদাহরণ পদ্ধতি)।

অপেক্ষা () এবং ঘুম () মধ্যে পার্থক্য

মৌলিক পার্থক্য wait() Object এবং sleep() থেকে Thread স্ট্যাটিক পদ্ধতি।
প্রধান পার্থক্য হল যে wait() sleep() সময় লকটি প্রকাশ করে sleep() অপেক্ষা করার সময় কোনও লক প্রকাশ করে না।
wait() সময় বিরতি sleep() ব্যবহার করার সময় wait() আন্ত-থ্রেড যোগাযোগের জন্য ব্যবহৃত হয়।
wait() ভেতরের সিঙ্ক্রোনাইজ থেকে কল করা উচিত অথবা অন্যথায় আমরা sleep() সময় IllegalMonitorStateException পেতে IllegalMonitorStateException sleep() যে কোন জায়গায় কল করতে পারে।
wait() থেকে আবার থ্রেড শুরু wait() , আপনাকে notify() করতে notify() বা notify() notifyAll() । sleep(), থ্রেড নির্দিষ্ট ms / sec ব্যবধানের পরে শুরু হয়।

সমানতা বুঝতে সাহায্য করে

উভয় বর্তমান থ্রেড না রানযোগ্য রাষ্ট্র মধ্যে যায়।
উভয় native পদ্ধতি।

wait() Object ক্লাসের একটি পদ্ধতি।
sleep() Thread বর্গ একটি পদ্ধতি।
sleep() থ্রেড এক্স মিলিসেকেন্ডের জন্য sleep অবস্থায় যেতে দেয়।
একটি থ্রেড ঘুমের মধ্যে যায় যখন it doesn't release the lock ।
wait() থ্রেড লক মুক্তি এবং goes to suspended state ।
এই থ্রেড সক্রিয় হবে যখন একটি notify() বা notifAll() পদ্ধতি একই বস্তুর জন্য বলা হয়।

অপেক্ষা করুন এবং ঘুম দুটি ভিন্ন জিনিস:

sleep() থ্রেড নির্দিষ্ট সময়ের জন্য কাজ বন্ধ করে দেয়।
wait() থ্রেডটি অবতরণ না হওয়া পর্যন্ত কাজ বন্ধ করে দেয় - অন বিজ্ঞপ্তিটি সাধারণত অন্যান্য থ্রেড দ্বারা সূচিত হয়।

এটি একটি খুব সহজ প্রশ্ন, কারণ এই পদ্ধতিগুলির একটি সম্পূর্ণ ভিন্ন ব্যবহার রয়েছে।

প্রধান পার্থক্যটি অপেক্ষা করার সময় লক বা মনিটরটি ছেড়ে দেওয়ার জন্য অপেক্ষায় থাকা কোনও লক বা মনিটর মুক্ত করে না। ঘুমানোর সময় এক্স-থ্রেড যোগাযোগের জন্য অপেক্ষা করা হয় যখন নিদ্রা সঞ্চালনের জন্য বিরতি প্রবর্তন করা হয়।

এটি কেবল একটি স্পষ্ট এবং মৌলিক ব্যাখ্যা ছিল, যদি আপনি তার চেয়ে বেশি চান তবে পড়া চালিয়ে যান।

wait() পদ্ধতির থ্রেড অপেক্ষা অবস্থায় চলে যায় এবং এটি স্বয়ংক্রিয়ভাবে ফিরে আসবে না যতক্ষণ না আমরা notify() (অথবা notify() (অথবা notify() notifyAll() যদি আপনার কাছে অপেক্ষা করার অবস্থায় আরও একটি থ্রেড থাকে এবং আপনি সবাইকে জাগাতে চান যারা থ্রেড)। এবং আপনি wait() বা notify() অথবা notify() notifyAll() পদ্ধতিগুলি অ্যাক্সেস করার জন্য সিঙ্ক্রোনাইজড বা বস্তু লক বা ক্লাস লক প্রয়োজন। এবং আরও একটি জিনিস, wait() পদ্ধতিটি আন্তঃ-থ্রেড যোগাযোগের জন্য ব্যবহৃত হয় কারণ যদি একটি থ্রেড অপেক্ষা অবস্থায় যায় তবে আপনাকে সেই থ্রেডটি ঘোরাতে আরেকটি থ্রেড দরকার।

কিন্তু sleep() ক্ষেত্রে sleep() এটি একটি পদ্ধতি যা কয়েক সেকেন্ডের জন্য বা আপনার চাওয়া সময়ের জন্য প্রক্রিয়াটি ধরে রাখার জন্য ব্যবহৃত হয়। কারণ আপনি যে থ্রেডটি ফেরত পেতে কোনও notify() বা notify() notifyAll() পদ্ধতি notifyAll() করার প্রয়োজন নেই। অথবা আপনি যে থ্রেড ফিরে কল অন্য কোন থ্রেড প্রয়োজন হয় না। ব্যবহারকারীর পালনের পরে একটি গেমের মত কিছু সেকেন্ডের পরে আপনি কিছু করতে চান তবে আপনি ব্যবহারকারীকে কম্পিউটারটি না হওয়া পর্যন্ত অপেক্ষা করতে চান তবে আপনি sleep() পদ্ধতিটি উল্লেখ করতে পারেন।

এবং আরও একটি গুরুত্বপূর্ণ পার্থক্য যা সাক্ষাত্কারে প্রায়ই জিজ্ঞাসা করা হয়: sleep() Thread বর্গের অন্তর্গত এবং wait() Object ক্লাসের অন্তর্গত।

এই sleep() এবং wait() মধ্যে সব পার্থক্য।

এবং উভয় পদ্ধতির মধ্যে একটি সাদৃশ্য রয়েছে: তারা উভয় চেক বিবৃতি তাই আপনাকে এই পদ্ধতিগুলি অ্যাক্সেস করার জন্য ধরা বা ছোঁড়ার চেষ্টা করতে হবে।

আমি আশা করি এটা তোমাকে সাহায্য করবে।

wait()একটি সিঙ্ক্রোনাইজড পদ্ধতির sleep()ভিতরে দেওয়া হয় তবে একটি অ-সিঙ্ক্রোনাইজড পদ্ধতির ভিতরে দেওয়া হয় কারণ wait()পদ্ধতি বস্তুর উপর লকটি ছেড়ে দেয় sleep()বা yield()ছেড়ে দেয় lock()।

sleep()পদ্ধতিটি বর্তমান থ্রেডকে নির্দিষ্ট সময়ের জন্য রাষ্ট্রটিকে অবরুদ্ধ করার জন্য চলমান অবস্থায় থেকে সরানোর কারণ করে। যদি বর্তমান থ্রেডটিতে কোনও বস্তুর লক থাকে তবে এটি এটি ধরে রাখে, যার মানে হল যে অন্য থ্রেডগুলি সেই বর্গ বস্তুর কোনও সিঙ্ক্রোনাইজড পদ্ধতি কার্যকর করতে পারে না।

wait() পদ্ধতিটি বর্তমান থ্রেডকে নির্দিষ্ট সময়ের জন্য বা নির্দিষ্ট সময়ের জন্য ব্লক অবস্থায় যেতে দেয়, তবে এই ক্ষেত্রে থ্রেড বস্তুর লকটি ছেড়ে দেয় (যার অর্থ অন্যান্য থ্রেডগুলি কলিং বস্তুর কোনও সিঙ্ক্রোনাইজড পদ্ধতি কার্যকর করতে পারে।

সিঙ্ক্রোনাইজড ব্লক থেকে কল করা উচিত: wait() পদ্ধতিটি সর্বদা সিঙ্ক্রোনাইজড ব্লক থেকে বলা wait()হয়, যাতে বস্তুটিকে বলা হয় এমন বস্তুর আগে বস্তুর মনিটর লক করার প্রয়োজন হয়। কিন্তু sleep()পদ্ধতিটি বাইরে সিঙ্ক্রোনাইজড ব্লক থেকে বলা যেতে পারে যেমন sleep()পদ্ধতিতে কোনো বস্তুর মনিটরের প্রয়োজন নেই।

IllegalMonitorStateException: যদি wait()পন্থার চেয়ে বস্তুর লক অর্জন ছাড়া বলা হয় IllegalMonitorStateExceptionরানটাইম নিক্ষিপ্ত হয়, কিন্তু sleep()পদ্ধতি কখনোই এই ধরনের ব্যতিক্রম ছোঁড়ার।

কোন ক্লাসের সাথে সম্পর্কিত: wait() পদ্ধতি java.lang.Objectশ্রেণীভুক্ত তবে sleep()মেথডটি java.lang.Threadক্লাসের অন্তর্গত ।

বস্তু বা থ্রেডে কল করা হয়েছে: wait() পদ্ধতি বস্তুতে বলা হয় তবে sleep()থ্রেডগুলিতে বস্তু নয় এমন পদ্ধতি বলা হয়।

থ্রেড স্টেট: যখন wait()বস্তুর উপর পদ্ধতি বলা হয়, বস্তুর মনিটর ধরে রাখা থ্রেডটি অপেক্ষা করার অবস্থায় চলে যায় এবং শুধুমাত্র তখনই notify()বা চালানো অবস্থায় ফিরে যেতে পারে যখন notifyAll()সেই বস্তুর উপর পদ্ধতিটি বলা হয়। এবং পরে থ্রেড অনুস্মারক সময়সূচী যে থ্রেড রানযোগ্য হতে চলমান রাষ্ট্র থেকে যেতে। যখন sleep()থ্রেডে বলা হয় তখন এটি অপেক্ষা করার জন্য অপেক্ষা করছে এবং ঘুমের সময় শেষ হওয়ার সময় রানযোগ্য অবস্থায় ফিরে যেতে পারে।

যখন সিঙ্ক্রোনাইজড ব্লক থেকে বলা হয়: যখন wait()থ্রেড বলা হয় তখন বস্তুর লক ছেড়ে যায়। কিন্তু sleep()সিঙ্ক্রোনাইজড ব্লক বা পদ্ধতি থ্রেড থেকে বলা হয় যখন পদ্ধতি বস্তু লক ছেড়ে না।

আরো Reference

wait এবং sleep পদ্ধতি খুব ভিন্ন:

Thread.sleep() "জেগে উঠা" কোন উপায় নেই,
object.wait() অপেক্ষা সময়কালে "জাগ্রত আপ" এর একটি উপায় আছে, অন্য থ্রেড দ্বারা notify বা notify notifyAll ।

এটা নিয়ে ভাবতে আসুন, নামগুলি সেই সম্মান নিয়ে বিভ্রান্তিকর। তবে sleep একটি আদর্শ নাম এবং WaitForSingleObject বা Win API এ WaitForMultipleObjects এর মতো।

ঘুম সম্পর্কে উদাহরণ লক প্রকাশ না এবং অপেক্ষা করে

এখানে দুটি ক্লাস আছে:

প্রধান : প্রধান পদ্ধতি এবং দুটি থ্রেড রয়েছে।

একক এই দুই স্ট্যাটিক পদ্ধতি getInstance () এবং getInstance (বুলিয়ান isWait) সঙ্গে Singleton বর্গ।

public class Main {

private static Singleton singletonA = null;
private static Singleton singletonB = null;

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

Thread threadA = new Thread() {
    @Override
    public void run() {

        singletonA = Singleton.getInstance(true);

    }
};

Thread threadB = new Thread() {
    @Override
    public void run() {
        singletonB = Singleton.getInstance();

        while (singletonA == null) {
            System.out.println("SingletonA still null");
        }

        if (singletonA == singletonB) {
            System.out.println("Both singleton are same");
        } else {
            System.out.println("Both singleton are not same");
        }

    }
};

threadA.start();
threadB.start();

 }
}

এবং

public class Singleton {

    private static Singleton _instance;

    public static Singleton getInstance() {

    if (_instance == null) {
        synchronized (Singleton.class) {
            if (_instance == null)
                _instance = new Singleton();
        }
    }
    return _instance;

}

public static Singleton getInstance(boolean isWait) {

    if (_instance == null) {
        synchronized (Singleton.class) {
            if (_instance == null) {
                if (isWait) {
                    try {
                        // Singleton.class.wait(500);//Using wait
                        Thread.sleep(500);// Using Sleep
                        System.out.println("_instance :"
                                + String.valueOf(_instance));
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }

                _instance = new Singleton();
            }
        }
    }
    return _instance;

 }
}

এখন এই উদাহরণটি চালান আপনি আউটপুট পাবেন:

_instance :null
Both singleton are same

এখানে থ্রেডএ এবং থ্রেডবি দ্বারা নির্মিত সিঙ্গলটন উদাহরণ একই। এর অর্থ হল থ্রেডবি বাইরে থ্রেড হওয়া অপেক্ষা করছে এটির লকটি ছেড়ে দেয়।

এখন Thread.sleep মন্তব্য করে Singleton.java পরিবর্তন করুন (500); পদ্ধতি এবং uncommenting Singleton.class.wait (500); ।এখানে Singleton.class.wait (500) এর কারণে; পদ্ধতি থ্রেড সমস্ত অ্যাক্টিভ লকগুলি ছেড়ে দেবে এবং "অ রানযোগ্য" অবস্থায় চলে যাবে, থ্রেডবি সিঙ্ক্রোনাইজ ব্লকটিতে প্রবেশ করতে পরিবর্তন পাবে।

এখন আবার রান করুন:

SingletonA still null
SingletonA still null
SingletonA still null
_instance :com.omt.sleepwait.[email protected]
SingletonA still null
SingletonA still null
SingletonA still null
Both singleton are not same

এখানে থ্রেডএ এবং থ্রেডবি দ্বারা তৈরি সিঙ্গল্ট ইনস্ট্যান্সগুলি একই নয় কারণ থ্রেডবি সিঙ্ক্রোনাইজড ব্লকটিতে প্রবেশের জন্য পরিবর্তন পেয়েছে এবং 500 মিলিসেকেন্ডের পরে থ্রেড এটির শেষ অবস্থান থেকে শুরু হয়েছে এবং আরও একক্টোন বস্তু তৈরি করেছে।

অপেক্ষা এবং ঘুমাতে কাজ করার পরে আমি কিছু পার্থক্য কী নোটগুলি শেষ করেছি, প্রথমে অপেক্ষা করুন () এবং ঘুম () ব্যবহার করে নমুনাটি দেখুন:

উদাহরণ 1 : অপেক্ষা () এবং ঘুম () ব্যবহার করে:

synchronized(HandObject) {
    while(isHandFree() == false) {
        /* Hand is still busy on happy coding or something else, please wait */
        HandObject.wait();
    }
}

/* Get lock ^^, It is my turn, take a cup beer now */
while (beerIsAvailable() == false) {
    /* Beer is still coming, not available, Hand still hold glass to get beer,
       don't release hand to perform other task */
    Thread.sleep(5000);
}

/* Enjoy my beer now ^^ */
drinkBeers();

/* I have drink enough, now hand can continue with other task: continue coding */
setHandFreeState(true);
synchronized(HandObject) {
    HandObject.notifyAll();
}

কিছু কী নোট স্বচ্ছতা যাক:

কল করুন :
- অপেক্ষা করুন (): HandObject Object ধারণ করে বর্তমান থ্রেডে কল করুন
- ঘুম (): থ্রেড এক্সিকিউট টাস্কে কল করুন বিয়ার পান (ক্লাস পদ্ধতিটি চলমান চলমান থ্রেডে প্রভাবিত হয়)
সিঙ্ক্রোনাইজড
- অপেক্ষা করুন (): যখন মাল্টি থ্রেড অ্যাক্সেস সিঙ্ক্রোনাইজ করা হয় তখন একই বস্তু (HandObject) (একই বস্তুতে একাধিক থ্রেড (থ্রেড এক্সিকিউট কোডিং, থ্রেড এক্সিকিউট বিয়ার পেতে) অ্যাক্সেসের প্রয়োজন হলে হ্যান্ডবাইটটি
- ঘুম (): অপেক্ষারত অবস্থায় অপেক্ষা করার সময় (অপেক্ষা বিয়ার উপলব্ধ)
লক ধরে রাখুন :
- অপেক্ষা করুন (): অন্যান্য বস্তুর জন্য লকটি কার্যকর করার সুযোগ রয়েছে (HandObject বিনামূল্যে, আপনি অন্য কাজ করতে পারেন)
- ঘুম (): অন্তত টি বারের জন্য লক রাখুন (বা বাধা না দেওয়া পর্যন্ত) (আমার কাজটি এখনও শেষ না হয়, আমি হোল্ড লক চালিয়ে যাচ্ছি এবং কিছু শর্ত অপেক্ষায় থাকি)
ওয়েক আপ অবস্থা :
- অপেক্ষা করুন (): কলটি অবহিত না হওয়া পর্যন্ত (), অবহিত করুন অল ()
- ঘুম (): অন্তত সময় মেয়াদ শেষ না হওয়া পর্যন্ত বা কল বিঘ্নিত
এবং শেষ বিন্দু ব্যবহার করা হয় যখন estani নির্দেশ করে:

আপনি সাধারণত সময়-সিঙ্ক্রোনাইজাইজেশনের জন্য ঘুম () ব্যবহার করেন এবং মাল্টি-থ্রেড-সিঙ্ক্রোনাইজেশনের জন্য () অপেক্ষা করুন।

আমি ভুল যদি আমাকে সঠিক করুন।

উৎস: http://www.jguru.com/faq/view.jsp?EID=47127

Thread.sleep() কিছু সময়ের জন্য বর্তমান থ্রেডটিকে "না চালানোর যোগ্য" অবস্থায় প্রেরণ করে। থ্রেড এটির দ্বারা পরিচালিত মনিটরগুলিকে রাখে - অর্থাৎ যদি থ্রেডটি বর্তমানে একটি সিঙ্ক্রোনাইজড ব্লক বা পদ্ধতিতে থাকে তবে অন্য কোন থ্রেড এই ব্লক বা পদ্ধতিতে প্রবেশ করতে পারবে না। যদি অন্য থ্রেড t.interrupt() কল করে তবে ঘুমন্ত থ্রেডটি ঘুম থেকে উঠবে।
মনে রাখবেন ঘুম একটি স্ট্যাটিক পদ্ধতি, যার মানে এটি সর্বদা বর্তমান থ্রেডকে প্রভাবিত করে (যেটি ঘুম পদ্ধতিটি কার্যকর করছে)। একটি সাধারণ ভুল হল t.sleep() কল যেখানে t একটি ভিন্ন থ্রেড হয়; তবুও, এটি বর্তমান থ্রেড যা ঘুমিয়ে থাকবে, টি থ্রেড নয়।
t.suspend() হয়। বর্তমান থ্রেড ছাড়া অন্য একটি থ্রেড থামাতে এটি ব্যবহার করা সম্ভব। একটি স্থগিত থ্রেড সব তার মনিটর রাখে এবং এই অবস্থা interruptable হয় না কারণ এটি বিলম্বিত prone হয়।
object.wait() বর্তমান থ্রেডকে "নন রান্নেবল" অবস্থায় sleep() , কিন্তু একটি মোড়ক দিয়ে প্রেরণ করে। অপেক্ষা একটি বস্তুর উপর বলা হয়, একটি থ্রেড নয়; আমরা এই বস্তুটিকে "লক অবজেক্ট" বলি। lock.wait() বলা হয়, বর্তমান থ্রেডটি লক অবজেক্টে সিঙ্ক্রোনাইজ করতে হবে; wait() তারপর এই লকটি রিলিজ করে এবং লকের সাথে সংযুক্ত "অপেক্ষা তালিকা" তে থ্রেড যোগ করে। পরে, অন্য থ্রেড একই লক অবজেক্টে সিঙ্ক্রোনাইজ করতে পারে এবং lock.notify() কল করতে lock.notify() । এই মূল, অপেক্ষা থ্রেড জেগে ওঠে। মূলত, wait() / notify() sleep() মত sleep() / interrupt() , শুধুমাত্র সক্রিয় থ্রেডটিকে ঘুমন্ত থ্রেডে সরাসরি পয়েন্টারের প্রয়োজন নেই, তবে শুধুমাত্র ভাগ করা লক বস্তুতে।

ব্যক্তিগত : শুধুমাত্র ক্লাসে সীমিত অ্যাক্সেস

ডিফল্ট (কোন সংশোধনকারী) : শ্রেণী এবং প্যাকেজ সীমিত অ্যাক্সেস

সুরক্ষিত : বর্গ, প্যাকেজ এবং উপশ্রেণীগুলিতে সীমিত অ্যাক্সেস (ভিতরে এবং বাইরে উভয় প্যাকেজ)

সর্বজনীন : ক্লাসে অ্যাক্সেসযোগ্য, প্যাকেজ (সমস্ত), এবং উপশ্রেণী ... সর্বত্র, সর্বত্র।