মাল্টিথ্রেডিং: থ্রেড ক্লাসের পদ্ধতিগুলি কী করে

ওহে! আজ আমরা মাল্টিথ্রেডিং সম্পর্কে কথা বলতে থাকব। আসুন থ্রেড ক্লাস পরীক্ষা করি এবং এর কয়েকটি পদ্ধতি কী করে। যখন আমরা আগে ক্লাস পদ্ধতিগুলি অধ্যয়ন করতাম, তখন আমরা সাধারণত এটি লিখতাম: <পদ্ধতির নাম> -> <পদ্ধতিটি কী করে>। এটি এর পদ্ধতিগুলির সাথে কাজ করবে না :) তাদের আরও জটিল যুক্তি রয়েছে যা আপনি কয়েকটি উদাহরণ ছাড়া বের করতে পারবেন না।Thread

Thread.start() পদ্ধতি

আসুন নিজেদের পুনরাবৃত্তি করে শুরু করি। আপনি সম্ভবত মনে রাখবেন, আপনি আপনার ক্লাসকে ক্লাসের উত্তরাধিকারী করে Threadএবং run()পদ্ধতিটিকে ওভাররাইড করে একটি থ্রেড তৈরি করতে পারেন। তবে এটি অবশ্যই নিজে থেকে শুরু হবে না। এটি করার জন্য, আমরা আমাদের বস্তুর start()পদ্ধতি কল. আগের পাঠ থেকে উদাহরণটি স্মরণ করা যাক:

public class MyFirstThread extends Thread {

   @Override
   public void run() {
       System.out.println("Thread executed: " + getName());
   }
}


public class Main {

   public static void main(String[] args) {

       for (int i = 0; i < 10; i++) {
           MyFirstThread thread = new MyFirstThread();
           thread.start();
       }
   }
}

দ্রষ্টব্য: একটি থ্রেড শুরু করতে, আপনাকে অবশ্যইstart()পরিবর্তে বিশেষ পদ্ধতিতেrun()! এটি করা একটি সহজ ত্রুটি, বিশেষ করে যখন আপনি প্রথম মাল্টিথ্রেডিং অধ্যয়ন শুরু করেন। আমাদের উদাহরণে, আপনি যদিrun()পদ্ধতিটিকে 10 বার এর পরিবর্তেstart()তবে আপনি এটি পাবেন:

public class Main {

   public static void main(String[] args) {

       for (int i = 0; i < 10; i++) {
           MyFirstThread thread = new MyFirstThread();
           thread.run();
       }
   }
}

আমাদের প্রোগ্রামের ফলাফল দেখুন: থ্রেড কার্যকর করা হয়েছে: থ্রেড-0 থ্রেড কার্যকর করা হয়েছে: থ্রেড-1 থ্রেড কার্যকর করা হয়েছে: থ্রেড-2 থ্রেড কার্যকর করা হয়েছে: থ্রেড-3 থ্রেড কার্যকর করা হয়েছে: থ্রেড-4 থ্রেড কার্যকর করা হয়েছে: থ্রেড-5 থ্রেড কার্যকর করা হয়েছে: থ্রেড-6 থ্রেড এক্সিকিউটেড: থ্রেড-7 থ্রেড এক্সিকিউটেড: থ্রেড-8 থ্রেড এক্সিকিউটেড: থ্রেড-9 আউটপুটের ক্রম দেখুন: সবকিছু নিখুঁত ক্রমে হচ্ছে। অদ্ভুত, হাহ? আমরা এটিতে অভ্যস্ত নই, কারণ আমরা ইতিমধ্যেই জানি যে থ্রেডগুলি যে ক্রমানুসারে শুরু এবং কার্যকর করা হয় তা আমাদের অপারেটিং সিস্টেমের মধ্যে একটি উচ্চতর বুদ্ধি দ্বারা নির্ধারিত হয়: থ্রেড শিডিউলার। হয়তো আমরা ভাগ্যবান? অবশ্যই, এটি ভাগ্য সম্পর্কে নয়। আপনি আরও কয়েকবার প্রোগ্রামটি চালিয়ে এটি যাচাই করতে পারেন। সমস্যা হল যে কলrun()মাল্টিথ্রেডিংয়ের সাথে পদ্ধতির সরাসরি কোন সম্পর্ক নেই। এই ক্ষেত্রে, প্রোগ্রামটি মূল থ্রেডে কার্যকর করা হবে, একই থ্রেড যা main()পদ্ধতিটি কার্যকর করে। এটি সহজভাবে কনসোলে 10টি লাইন মুদ্রণ করে এবং এটিই। 10টি থ্রেড শুরু করা হয়নি। সুতরাং, ভবিষ্যতে এটি মনে রাখবেন এবং ক্রমাগত নিজেকে পরীক্ষা করুন। আপনি যদি run()পদ্ধতিটি কল করতে চান তবে কল করুন start()। আরো এগিয়ে যাক.

Thread.sleep() পদ্ধতি

কিছু সময়ের জন্য বর্তমান থ্রেডের সম্পাদন স্থগিত করতে, আমরা sleep()পদ্ধতিটি ব্যবহার করি। পদ্ধতিটি sleep()একটি যুক্তি হিসাবে অনেক মিলিসেকেন্ড নেয়, যা থ্রেডটিকে ঘুমাতে কতটা সময় নির্দেশ করে।

public class Main {

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

       long start = System.currentTimeMillis();

       Thread.sleep(3000);

       System.out.println(" - How long did I sleep? \n - " + ((System.currentTimeMillis()-start)) / 1000 + " seconds");

   }
}

কনসোল আউটপুট: - আমি কতক্ষণ ঘুমিয়েছিলাম? - 3 সেকেন্ড দ্রষ্টব্য: পদ্ধতিটি sleep()স্থির: এটি বর্তমান থ্রেডকে স্লিপ করে। অর্থাৎ বর্তমানে যেটির মৃত্যুদন্ড কার্যকর করা হচ্ছে। এখানে আরেকটি গুরুত্বপূর্ণ বিন্দু: একটি ঘুমের থ্রেড বিঘ্নিত হতে পারে। এই ক্ষেত্রে, প্রোগ্রাম একটি নিক্ষেপ InterruptedException. আমরা নীচে একটি উদাহরণ বিবেচনা করব। যাইহোক, থ্রেড জেগে ওঠার পরে কি হয়? এটা কি ঠিক যেখান থেকে বাম সেখান থেকে কার্যকর করা চলবে? না। একটি থ্রেড জেগে ওঠার পর, অর্থাত্‍ একটি যুক্তি হিসাবে যে সময়টি অতিবাহিত হয়ে Thread.sleep()গেছে, সেটি রানেবলে রূপান্তরিত হয়অবস্থা. কিন্তু, এর মানে এই নয় যে থ্রেড সময়সূচী এটি চালাবে। এটি সম্ভবত অন্য কিছু অ-নিদ্রা থ্রেডকে অগ্রাধিকার দিতে পারে এবং আমাদের সদ্য-জাগ্রত থ্রেডটিকে একটু পরে তার কাজ চালিয়ে যেতে দেয়। এটি মনে রাখতে ভুলবেন না: জেগে ওঠা মানে অবিলম্বে কাজ চালিয়ে যাওয়া নয়!

Thread.join() পদ্ধতি

এই join()পদ্ধতিটি অন্য থ্রেড শেষ না হওয়া পর্যন্ত বর্তমান থ্রেডের কার্য সম্পাদন স্থগিত করে। যদি আমাদের 2টি থ্রেড থাকে, t1এবং t2, এবং আমরা লিখি

t1.join()

তারপর কাজ শেষ না হওয়া t2পর্যন্ত শুরু হবে না । t1পদ্ধতিটি join()থ্রেডের নির্বাহের আদেশ নিশ্চিত করতে ব্যবহার করা যেতে পারে। join()নিম্নলিখিত উদাহরণে পদ্ধতিটি কীভাবে কাজ করে তা বিবেচনা করা যাক :

public class ThreadExample extends Thread {

   @Override
   public void run() {

       System.out.println("Thread started: " + getName());

       try {
           Thread.sleep(5000);
       } catch (InterruptedException e) {
           e.printStackTrace();
       }
       System.out.println("Thread " + getName() + " is finished.");
   }
}


public class Main {

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

       ThreadExample t1 = new ThreadExample();
       ThreadExample t2 = new ThreadExample();

       t1.start();


 /* The second thread (t2) will start running only after the first thread (t1)
       is finished (or an exception is thrown) */
       try {
           t1.join();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

       t2.start();

       // The main thread will continue running only after t1 and t2 have finished
       try {
           t1.join();
           t2.join();
       } catch (InterruptedException e) {
           e.printStackTrace();
       }

       System.out.println("All threads have finished. The program is finished.");

   }
}

আমরা একটি সাধারণ ThreadExampleক্লাস তৈরি করেছি। এর কাজ হল একটি বার্তা প্রদর্শন করা যে থ্রেডটি শুরু হয়েছে, 5 সেকেন্ডের জন্য ঘুমিয়ে পড়ুন এবং তারপর অবশেষে রিপোর্ট করুন যে কাজটি সম্পূর্ণ হয়েছে। খুবই সহজ. মূল যুক্তি ক্লাসে Main। মন্তব্যগুলি দেখুন: আমরা join()সফলভাবে থ্রেডের এক্সিকিউশন অর্ডার পরিচালনা করতে পদ্ধতিটি ব্যবহার করি। যদি আপনি মনে করেন যে আমরা এই বিষয়টি কীভাবে শুরু করেছি, কার্যকর করার আদেশ থ্রেড শিডিউলার দ্বারা পরিচালিত হয়। এটি তার নিজস্ব বিবেচনার ভিত্তিতে থ্রেড চালায়: প্রতিটি সময় একটি ভিন্ন উপায়ে। এখানে আমরা গ্যারান্টি দেওয়ার জন্য পদ্ধতিটি ব্যবহার করছি যে t1থ্রেডটি প্রথমে শুরু হবে এবং প্রথমে কার্যকর করা হবে, তারপরেt2থ্রেড, এবং শুধুমাত্র তার পরে প্রোগ্রামের মূল থ্রেড চলতে থাকবে। সরানো. বাস্তব প্রোগ্রামগুলিতে, আপনি প্রায়শই এমন পরিস্থিতিতে পাবেন যখন আপনাকে একটি থ্রেড কার্যকর করতে বাধা দিতে হবে। উদাহরণস্বরূপ, আমাদের থ্রেড চলছে, কিন্তু এটি একটি নির্দিষ্ট ঘটনা বা অবস্থার জন্য অপেক্ষা করছে। যদি এটি ঘটে তবে থ্রেডটি বন্ধ হয়ে যায়। এটি সম্ভবত অর্থপূর্ণ হবে যদি কিছু stop()পদ্ধতি ছিল। কিন্তু এটা এত সহজ নয়। এক সময়, জাভা আসলে একটি পদ্ধতি ছিল Thread.stop()এবং একটি থ্রেড বাধা দেওয়া অনুমতি দেয়. কিন্তু পরে এটি জাভা লাইব্রেরি থেকে সরিয়ে ফেলা হয়। আপনি ওরাকল ডকুমেন্টেশনে এটি খুঁজে পেতে পারেন এবং দেখতে পারেন যে এটি অবচয় হিসাবে চিহ্নিত করা হয়েছে. কেন? কারণ এটি অন্য কিছু না করেই থ্রেড বন্ধ করে দিয়েছে। উদাহরণস্বরূপ, থ্রেডটি ডেটা নিয়ে কাজ করছে এবং কিছু পরিবর্তন করছে। তারপরে এর কাজের মাঝখানে এটি হঠাৎ এবং অপ্রত্যাশিতভাবে stop()পদ্ধতি দ্বারা কেটে দেওয়া হয়েছিল। একটি সঠিক শাটডাউন ছাড়া, বা সংস্থান প্রকাশ না করা, এমনকি ত্রুটি পরিচালনা না করা - এর কিছুই ছিল না। সামান্য অতিরঞ্জিত করার জন্য, stop()পদ্ধতিটি তার পথে সবকিছু ধ্বংস করে দিয়েছে। এটি কম্পিউটার বন্ধ করার জন্য আউটলেট থেকে পাওয়ার কর্ড টানার মতো ছিল। হ্যাঁ, আপনি পছন্দসই ফলাফল পেতে পারেন। কিন্তু সবাই জানে যে কয়েক সপ্তাহ পরে কম্পিউটারটি এইভাবে আচরণ করার জন্য আপনাকে ধন্যবাদ জানাবে না। এই কারণেই জাভাতে থ্রেড বাধা দেওয়ার যুক্তি পরিবর্তিত হয়েছে এবং এখন একটি বিশেষ interrupt()পদ্ধতি ব্যবহার করে।

Thread.interrupt() পদ্ধতি

interrupt()যদি পদ্ধতিটি একটি থ্রেডে বলা হয় তবে কী হবে ? 2টি সম্ভাবনা রয়েছে:

1. joinযদি অবজেক্টটি অপেক্ষমাণ অবস্থায় থাকে, উদাহরণস্বরূপ, বা পদ্ধতির কারণে sleep, তাহলে অপেক্ষা বাধাগ্রস্ত হবে এবং প্রোগ্রামটি একটি নিক্ষেপ করবে InterruptedException।
2. যদি থ্রেডটি কার্যকরী অবস্থায় থাকে, তাহলে বুলিয়ান interruptedপতাকাটি বস্তুতে সেট করা হবে।

কিন্তু আমাদেরকে বস্তুর উপর এই পতাকার মান যাচাই করতে হবে এবং নিজের কাজটি সঠিকভাবে সম্পন্ন করতে হবে! তাই Threadক্লাসের পদ্ধতি আছে boolean isInterrupted()। ঘড়ির উদাহরণে ফিরে আসা যাক যা বেসিক কোর্সের একটি পাঠে ছিল। সুবিধার জন্য, আমরা এটিকে কিছুটা সরলীকৃত করেছি:

public class Clock extends Thread {

   public static void main(String[] args) throws InterruptedException {
       Clock clock = new Clock();
       clock.start();

       Thread.sleep(10000);
       clock.interrupt();
   }

   public void run() {
       Thread current = Thread.currentThread();

       while (!current.isInterrupted())
       {
           try {
               Thread.sleep(1000);
           } catch (InterruptedException e) {
               System.out.println("The thread was interrupted");
               break;
           }
           System.out.println("Tick");
       }
   }
}

এই ক্ষেত্রে, ঘড়ি শুরু হয় এবং প্রতি সেকেন্ডে টিক টিক শুরু করে। 10 তম সেকেন্ডে, আমরা ঘড়ির থ্রেডকে বাধা দিই। আপনি ইতিমধ্যেই জানেন, আমরা যে থ্রেডটি বাধা দেওয়ার চেষ্টা করছি সেটি যদি অপেক্ষারত অবস্থায় থাকে, তাহলে ফলাফল হল একটি InterruptedException। এটি একটি চেক করা ব্যতিক্রম, তাই আমরা সহজেই এটি ধরতে পারি এবং প্রোগ্রামটি শেষ করার জন্য আমাদের যুক্তি কার্যকর করতে পারি। এবং যে শুধু আমরা কি. এখানে আমাদের ফলাফল: টিক টিক টিক টিক টিক টিক টিক টিক টিক টিক টিক টিক থ্রেড বাধাগ্রস্ত হয়েছিল এটি Threadক্লাসের সবচেয়ে গুরুত্বপূর্ণ পদ্ধতিগুলির সাথে আমাদের পরিচিতি শেষ করে। শুভকামনা!