Java الكلاس `Thread` في جافا

مقدمة

يستخدم الكلاس Thread لجعل البرنامج قادر على تنفيذ عدة أوامر مع بعض في وقت واحد, و هو يملك عدة دوال و خصائص تجعلك قادراً على التحكم بطريقة تنفيذ هذه الأوامر.

كل كائن نوعه Thread تقوم بإنشائه, يكون الهدف منه تنفيذ مجموعة أوامر أثناء تنفيذ أوامر أخرى.

كل كائن Thread تقوم بإنشاءه, يتم إعطاءه رقم تعرفة ( id ) و إسم ( name ) خاص فيه, بالتالي يمكن الوصول لكائن الـ Thread من خلال رقم التعرفة أو الإسم الذي أعطي له.

بالإضافة إلى ذلك, يملك كل كائن Thread رقم بين 1 و 10 يحدد أولية التنفيذ ( Priority ).
كائن الـ Thread الذي يملك أعلا Priority يتم تنفيذ أوامره في الأول. لذلك, تلاعب بهذا الرقم فقط في حال كان عندك كائن Thread أهم من غيره.
تلقائياً, أي كائن Thread تقوم بإنشائه, يتم إعطائه Priority تساوي 5 حتى يتم تنفيذ جميع أوامر كائنات الـ Thread بشكل متوازي و عادل.

بناؤه

public class Thread
extends Object
implements Runnable

بما أن الكلاس Thread يطبق الإنترفيس Runnable, فهذا يؤكد أنهما مصممان لنفس الغرض, و هو جعل البرنامج قادراً على تنفيذ عدة أوامر مع بعض في وقت واحد.

خطوات بناء Thread بواسطة الكلاس `Thread`

نفعل extends للكلاس Thread.
نفعل Override للدالة run() لنضع جميع الأوامر التي نريدها أن تتنفذ عند تشغيل كائن الـ Thread.

مثال

MyThread.java

public class MyThread extends Thread {

    @Override
    public void run(){
        // start() هنا تضع الأوامر التي تريد تنفيذها عند إستدعاء الدالة
    }

}

خطوات إنشاء الـ `Thread` و تشغيله

ننشئ كائن من الكلاس الذي يرث من الكلاس Thread.
نستدعي الدالة start() لتشغيل كائن الـ Thread.

مثال

Main.java

public class Main {

    public static void main(Strigns[] args)){

        MyThread t = new MyThread();
        t.start();

    }

}

في حال قمت بتشغل كائن الـ Thread بواسطة الدالة run() بدل الدالة start(), عندها ستعامل الدالة run() كدالة عادية, أي سيتم إيقاف باقي الأوامر الموجودة في الدالة main() حتى يتم تنفيذ الأوامر الموجودة بداخل الدالة run() ثم العودة للدالة main() لمتابعة تنفيذ باقي الأوامر الموجودة فيها.

الحالات التي يمر بها الـ `Thread` (Thread States)

عندما تتعامل مع الـ Thread فأنت بذلك تقوم بتغيير حالته, فمرة تنشئه, و مرة تجهزه و تشغله, و قد توقفه عن العمل مدة معينة ثم تعيده للعمل بعد مدة, و عند الإنتهاء يتم مسحه من الذاكرة لتوفير مساحة التخزين.

في الجدول التالي ذكرنا الحالات التي يمر بها الـ Thread.

الحالة	معناها
`NEW`	هذه الحالة تعني أن كائن الـ `Thread` قد تم إنشاءه في الذاكرة.
`RUNNABLE`	هذه الحالة تعني أن كائن الـ `Thread` أصبح جاهزاً و يمكن تنفيذ أوامره.
`TIMED_WAITING`	هذه الحالة تعني أن كائن الـ `Thread` قد تم إيقافه عن التنفيذ لمدة معينة.
`BLOCKED`	هذه الحالة تعني أن كائن الـ `Thread` موقوف لحين تنفيذ أوامر `Thread` آخر.
`WAITING`	هذه الحالة تعني أن كائن الـ `Thread` تم إيقافه عن التنفيذ لبعض الوقت ريثما ينتهي تنفيذ أوامر `Thread` آخر.
`TERMINATED`	هذه الحالة تعني أن كائن الـ `Thread` تم إيقافه نهائياً, و تم مسحه من الذاكرة.

ملاحظة: بعد أن تصبح حالة كائن الـ Thread تساوي TERMINATED يمكن إعطاء رقم التعرفة و إسم الكائن السابق لكائن Thread آخر.

كونستركتورات الكلاس `Thread`

في الجدول التالي ذكرنا جميع كونستركتورات الكلاس Thread.

الكونستركتور مع تعريفه
`public Thread()` ينشئ كائن نوعه `Thread` ليس له إسم محدد.
`public Thread(String name)` ينشئ كائن نوعه `Thread` مع تحديد إسمه.
`public Thread(Runnable target)` ينشئ كائن نوعه `Thread` من كائن نوعه `Runnable`.
`public Thread(Runnable target, String name)` ينشئ كائن نوعه `Thread` من كائن نوعه `Runnable` مع تحديد إسمه.
`public Thread(ThreadGroup group, String name)` ينشئ كائن نوعه `Thread` و يضعه ضمن مجموعة محددة, مع تحديد إسمه. باراميترات `group` عبارة عن كائن نوعه `ThreadGroup` يمثل مجموعة من الـ Threads. `name` عبارة عن إسم يتم إعطاءه لكائن الـ `Thread` الذي سيتم إنشاءه و وضعه ضمن المجموعة المذكورة. يرمي الإستثناء SecurityException في حال كان كائن الـ `Thread` الحالي لا يملك صلاحية إنشاء كائن `Thread` جديد بداخل المجموعة المشار إليها.
`public Thread(ThreadGroup group, Runnable target)` ينشئ كائن نوعه `Thread` من كائن نوعه `Runnable` و يضعه ضمن مجموعة محددة. باراميترات `group` عبارة عن كائن نوعه `ThreadGroup` يمثل مجموعة من الـ Threads. `target` عبارة عن كائن نوعه `Runnable` يمثل كائن الـ `Thread` الذي سيتم إنشاءه و وضعه ضمن المجموعة المذكورة. يرمي الإستثناء SecurityException في حال كان كائن الـ `Thread` الحالي لا يملك صلاحية إنشاء كائن `Thread` جديد بداخل المجموعة المشار إليها.
`public Thread(ThreadGroup group, Runnable target, String name)` ينشئ كائن نوعه `Thread` من كائن نوعه `Runnable` و يضعه ضمن مجموعة محددة, مع تحديد إسمه. باراميترات `group` عبارة عن كائن نوعه `ThreadGroup` يمثل مجموعة من الـ Threads. `target` عبارة عن كائن نوعه `Runnable` يمثل كائن الـ `Thread` الذي سيتم إنشاءه و وضعه ضمن المجموعة المذكورة. `name` عبارة عن إسم يتم إعطاءه لكائن الـ `Thread` الذي سيتم إنشاءه و وضعه ضمن المجموعة المذكورة. يرمي الإستثناء SecurityException في حال كان كائن الـ `Thread` الحالي لا يملك صلاحية إنشاء كائن `Thread` جديد بداخل المجموعة المشار إليها.
`public Thread(ThreadGroup group, Runnable target, String name, long stackSize)` ينشئ كائن نوعه `Thread` من كائن نوعه `Runnable` و يضعه ضمن مجموعة محددة, مع تحديد إسمه, و تحديد المساحة القصوى التي يمكن أن تحجز له في الذاكرة. باراميترات `group` عبارة عن كائن نوعه `ThreadGroup` يمثل مجموعة من الـ Threads. `target` عبارة عن كائن نوعه `Runnable` يمثل كائن الـ `Thread` الذي سيتم إنشاءه و وضعه ضمن المجموعة المذكورة. `name` عبارة عن إسم يتم إعطاءه لكائن الـ `Thread` الذي سيتم إنشاءه و وضعه ضمن المجموعة المذكورة. `stackSize` عبارة عن المساحة القصوى التي يمكن أن يحتلها كائن الـ `Thread` في الذاكرة. يرمي الإستثناء SecurityException في حال كان كائن الـ `Thread` الحالي لا يملك صلاحية إنشاء كائن `Thread` جديد بداخل المجموعة المشار إليها.

دوال الكلاس `Thread`

الجدول التالي يحتوي على دوال الكلاس Thread.

الدالة مع تعريفها
`public void run()` تستخدم لتجهيز الأوامر التي ستنفذ عند تشغيل الـ `Thread`. الكلاس الذي يرث من الكلاس `Thread` يجب أن يفعل لها Override, و يضع بداخلها الأوامر التي يريدها أن تتنفذ عند تشغيل الـ `Thread`. ملاحظة: لتشغيل الـ `Thread` عليك إستدعاء الدالة `start()` و التي بدورها تقوم باستدعاء الدالة `run()`, أي تنفذ الأوامر الموجودة فيها.
`public void start()` تستخدم لتشغيل كائن الـ `Thread`, أي لتنفيذ الأوامر التي تم وضعها في الدالة `run()`. ترمي الإستثناء IllegalThreadStateException في حال كان كائن الـ `Thread` شغالا قبل استدعائها.
`public static void sleep(long milliseconds)` توقف تنفيذ أوامر كائن الـ `Thread` الذي قام باستدعائها لمدة محددة. بعد إنتهاء هذه المدة يعود للعمل من جديد. `milliseconds` هو المدة التي سيتوقف فيها كائن الـ `Thread` بالـ Milli Seconds. فمثلاً إذا وضعت 1000 مكان هذا الباراميتر, سؤدي ذلك إلى إيقاف كائن الـ `Thread` عن التنفيذ لثانية واحدة. ترمي الإستثناء IllegalThreadStateException في حال تم إعطاءها قيمة أصغر من 0. ترمي الإستثناء InterruptedException في حال تم إيقاف كائن الـ `Thread` في فترة إنتظاره.
`public static void suspend()` توقف تنفيذ أوامر كائن الـ `Thread` الذي قام باستدعائها لمدة غير محددة, بحيث لا يمكنه العودة للعمل من جديد إلا إذا قام باستدعاء الدالة `resume()` بعدها. ترمي الإستثناء SecurityException في حال كان كائن الـ `Thread` الحالي لا يملك صلاحية التعديل على كائن الـ `Thread` المتوقف عن العمل.
`public static void resume()` تكمل تنفيذ أوامر كائن الـ `Thread` بعد أن كان قد توقف عن تنفيذها بسبب الدالة `suspend()`. ترمي الإستثناء SecurityException في حال كان كائن الـ `Thread` الحالي لا يملك صلاحية التعديل على كائن الـ `Thread` المتوقف عن العمل.
`public static void stop()` توقف كائن الـ `Thread` الذي قام باستدعائها, بحيث لا يمكنه العودة للعمل من جديد. ترمي الإستثناء SecurityException في حال كان كائن الـ `Thread` الحالي لا يملك صلاحية التعديل على كائن الـ `Thread` المتوقف عن العمل.
`public final void join()` تجعل البرنامج لا يتابع تنفيذ الأوامر الموجودة في الدالة `main()` حتى يتم تنفيذ جميع الأوامر الموجودة في كائن الـ `Thread` الذي قام باستدعائها, أي حتى تصبح حالته تساوي `TERMINATED`. ملاحظة: لا يهمها إذا كان يوجد أكثر من كائن `Thread` آخر شغال في نفس الوقت. بمعنى أنه إذا كان هناك كائن `Thread` آخر شغال فإنه سيستمر في العمل بشكل طبيعي, لكن باقي الأوامر الموجودة في الدالة `main()` لن يتم تنفيذهم حتى تنفيذ جميع أوامر كائن الـ `Thread` الذي قام باستدعائها. ترمي الإستثناء InterruptedException في حال تم إيقاف كائن الـ `Thread` من قبل أي كائن `Thread` آخر.
`public void interrupt()` ترسل إشارة إلى الـ JVM لمقاطعة عمل كائن الـ `Thread` في حال كان شغالاً. في حال كان كائن الـ `Thread` متوقفاً لمدة بسبب إحدى الدوال مثل `join()` و `wait()` و `sleep()`, فإنها لا تؤثر عليه أبداً. في حال كان كائن الـ `Thread` غير شغال بعد لا تؤثر عليه أيضاً. ترمي الإستثناء SecurityException في حال كان كائن الـ `Thread` الحالي لا يملك صلاحية التعديل على كائن الـ `Thread` المتوقف عن العمل. معلومة: قد تحتاج هذه الدالة في حال كنت تريد إيقاف كائن الـ `Thread` ريثما تنتهي من تنفيذ أوامر أخرى أكثر أهمية, في حال نجحت هذه الدالة تكون مدة إيقاف كائن الـ `Thread` عن العمل غير محددة.
`public boolean isInterrupted()` تستخدم لمعرفة إذا كان كائن الـ `Thread` قد توقف بسبب استدعاء الدالة `interrupt()` أم لا. ترجع `true` في حال تم استدعاء الدالة `interrupt()` قبلها و قد تمكنت هذه الأخيرة من مقاطعة كائن الـ `Thread` أثناء تنفيذ الأوامر. غير ذلك ترجع `false`.
`public long getId()` ترجع رقم الـ ID الذي تم إعطاءه لكائن الـ `Thread`.
`public Thread.State getState()` ترجع كائن نوعه `Thread.State` يمثل حالة كائن الـ `Thread` الذي قام باستدعائها.
`public final boolean isAlive()` ترجع `true` في حال لم يكن كائن الـ `Thread` الذي قام باستدعائها في الحالة `TERMINATED`. غير ذلك ترجع `false`.
`public String toString()` ترجع نص يمثل معلومات كائن الـ `Thread` الذي قام باستدعائها. المعلومات عبارة عن ( Group - Priority - Name ). Name: هو إسم كائن الـ `Thread`. Priority: هو أولية التفيذ المعطاة لكائن الـ `Thread`. Group: هو إسم المجموعة التي ينتمي لها كائن الـ `Thread`.
`public final void setName(String name)` تستخدم لإعطاء إسم لكائن الـ `Thread`. ترمي الإستثناء SecurityException في حال كان كائن الـ `Thread` الحالي لا يملك صلاحية تغييرها.
`public final String getName()` ترجع إسم كائن الـ `Thread`.
`public final int setPriority(int newPriority)` تستخدم لتغيير قيمة الـ Priority المعطاة لكائن الـ `Thread`. الـ Priority التي تعطى إفتراضياً لأي `Thread` جديد هي 5, و هي تساوي قيمة الثابت `NORM_PRIORITY`. أعلا Priority يمكن إعطاءها للـ `Thread` هي 10, و هي تساوي قيمة الثابت `MAX_PRIORITY`. أدنى Priority يمكن إعطاءها للـ `Thread` هي 1, و هي تساوي قيمة الثابت `MIN_PRIORITY`. ترمي الإستثناء IllegalArgumentException في حال كانت القيمة التي قمت بتمريرها أصغر من 1 أو أكبر من 10. و ترمي الإستثناء SecurityException في حال كان كائن الـ `Thread` الحالي لا يملك صلاحية تغييرها.
`public final int getPriority()` ترجع رقم بين 1 و 10 عبارة عن قيمة الـ Priority التي يملكها كائن الـ `Thread` الذي قام باستدعائها.
`public final void setDaemon(boolean on)` تستخدم لتحويل كائن الـ `Thread` الذي قام باستدعائها إلى Daemon Thread. في حال قمت بتمرير القيمة `true` لها كـ Argument, سيتم معاملة كائن الـ `Thread` كــ Daemon Thread غير ذلك سيتم إعتباره Thread عادي. ترمي الإستثناء IllegalArgumentException في حال كان كائن الـ `Thread` شغالا أثناء استدعاءها. و ترمي الإستثناء SecurityException في حال كان كائن الـ `Thread` الحالي لا يملك صلاحية تغييرها.
`public final boolean isDaemon()` تستخدم لمعرفة إذا كان كائن الـ `Thread` الذي قام باستدعائها هو Daemon Thread أم لا. ترجع `true` إذا كان كذلك, غير ذلك ترجع `false`.
`public static int activeCount()` تستخدم لمعرفة عدد الـ threads الذين يعملون في البرنامج لحظة استدعائها. تستخدم فقط في حالة الـ Debugging. ملاحظة: في حال لم يكن هناك أي `Thread` شغال أو معرف في البرنامج, فإنها أيضاً ترجع 1 و الذي هو عبارة عن البرنامج نفسه.
`public static Thread currentThread()` ترجع كائن نوعه `Thread` يشير إلى كائن الـ `Thread` الذي قام باستدعائها.
`public final ThreadGroup getThreadGroup()` ترجع كائن نوعه `ThreadGroup` يمثل المجموعة التي ينتمي إليها كائن الـ `Thread` الذي قام باستدعائها. ترجع `true` في حال كانت حالة كائن الـ `Thread` تساوي `TERMINATED`.

أمثلة شاملة

المثال الأول

المثال التالي عبارة عن برنامج يعرض الوقت الحالي للجهاز.

في البداية قمنا بإنشاء كلاس إسمه RealTime يرث من الكلاس Thread.
بعدها فعلنا Override للدالة run() لجعلها تطبع الوقت الحالي.

ثم قمنا بإنشاء كلاس إسمه Main لتجربة هذا الـ Thread.
في الكلاس Main قمنا بإنشاء كائن من الكلاس RealTime ثم قمنا بتشغيله بواسطة الدالة start().

RealTime.java

import java.util.Date;		// Date هنا قمنا باستدعاء الكلاس
 
public class RealTime extends Thread {
 
    @Override
    public void run() {
        // true لا ترجع isInterrupted() طالما أن الدالة
        while(!Thread.currentThread().isInterrupted())
        {
            // سيتم طباعة الوقت الحالي
            System.out.printf("Current time: %tr \n", new Date());
 
            // لثانية واحدة Thread بعدها سيتم إيقاف كائن الـ
            try {
                Thread.sleep(1000);
            }
            catch(Exception e) {
                System.out.println(e.getMessage());
            }
        }
    }
 
}

Main.java

public class Main {
 
    public static void main(String[] args) {
 
        // t إسمه RealTime هنا قمنا بإنشاء كائن من الكلاس
        RealTime t = new RealTime();
 
        // لعرض الوقت t هنا قمنا بتشغيل الكائن
        t.start();
 
    }
 
}

عند تشغيل البرنامج, سيتم عرض الوقت الحالي كل ثانية كالتالي.

Current time: 09:02:15 AM
Current time: 09:02:16 AM
Current time: 09:02:17 AM
Current time: 09:02:18 AM
Current time: 09:02:19 AM
Current time: 09:02:20 AM
Current time: 09:02:21 AM
Current time: 09:02:22 AM
Current time: 09:02:23 AM
Current time: 09:02:24 AM
Current time: 09:02:25 AM
Current time: 09:02:26 AM
Current time: 09:02:27 AM
....

المثال الثاني

المثال التالي عبارة عن برنامج لإختبار قدرة المستخدم في العمليات الحسابية, فهو يقوم بخلق عمليات جمع عشوائية خلال مدة معينة, و إنتظار المستخدم للإجابة عليها, و في الأخير سيتم عرض النتيجة النهائية له.

في البداية قمنا بإنشاء كلاس إسمه ExamTimer يرث من الكلاس Thread.
بعدها فعلنا Override للدالة run() حتى نجعل أي كائن من الكلاس ExamTimer ينتظر مدة 20 ثانية بعد تشغيله, ثم يتوقف مباشرةً عن العمل.

ثم قمنا بإنشاء كلاس إسمه Main, و الذي سيستخدم الكلاس ExamTimer كمؤقت.
في الكلاس Main فعلنا الأشياء التالية:

أنشأنا كائن من الكلاس ExamTimer إسمه et.
قمنا بتشغيل الكائن et بواسطة الدالة start().
قمنا بتعريف المتغيرات num1 و num2 لتخزين الأرقام العشوائية التي سيتم توليدها في البرنامج.
قمنا بتعريف المتغير userAnswer لتخزين العدد الذي سيدخله المستخدم في كل مرة.
قمنا بتعريف المتغيرات operationsCounter, correctAnswersCounter و wrongAnswersCounter كعدادات في البرنامج.
operationsCounter: لتخزين عدد العمليات التي تظهر أمام المستخدم.
correctAnswersCounter: لتخزين عدد إجابات المستخدم الصحيحة.
wrongAnswersCounter: لتخزين عدد إجابات المستخدم الخاطئة.
قمنا بتعريف حلقة while تستمر في توليد أرقام العشوائية, إعداد عمليات جمع و إنتظار المستخدم لإدخال الإجابة بالإعتماد على الدالة isAlive() التي تبقي الحلقة تعيد تنفيذ الأوامر الموجودة فيها طالما أن مدة الإنتظار المحددة للكائن et غير منتهية بعد.

ExamTimer.java

public class ExamTimer extends Thread {
 
    @Override
    public void run() {
        // لثانية واحدة Thread بعدها سيتم إيقاف كائن الـ
        try {
            Thread.sleep(20000);
        }
        catch(Exception e) {
            System.out.println(e.getMessage());
        }
    }
 
}

Main.java

import java.util.Scanner;		// Scanner هنا قمنا باستدعاء الكلاس
 
public class Main {
 
    public static void main(String[] args) {
 
        // و الذي سنستخدمه لإدخال بيانات من المستخدم input إسمه Scanner هنا قمنا بإنشاء كائن من الكلاس
        Scanner input = new Scanner(System.in);
 
        // et إسمه ExamTimer هنا قمنا بإنشاء كائن من الكلاس
        ExamTimer et = new ExamTimer();
 
        int num1;                           // سنستخدم هذا المتغير لتخزين أول رقم عشوائي يظهر في عملية الجمع
        int num2;                           // سنستخدم هذا المتغير لتخزين ثاني رقم عشوائي يظهر في عملية الجمع
        int userAnswer;                     // سنستخدم هذا المتغير لتخزين العدد الذي سيدخله المستخدم للإجابة على عمليأت الجمع
        int operationsCounter = 0;          // سنخزن عدد العمليات الحسابية التي ستظهر عند تشغيل البرنامج فيه
        int correctAnswersCounter = 0;      // سنخزن عدد الإجابات الصحيحة في هذا المتغير
        int wrongAnswersCounter = 0;        // سنخزن عدد الإجابات الخطئ من ي هذا المتغير
 
        // الأمر الذي سيجعله في حالة إنتظار مدة 20 ثانية فقط و بعدها سيتوقف كلياً et هنا قمنا بتشغيل الكائن
        et.start();
 
        System.out.println("---------- Quiz ---------");
 
        // طالما أن مدة العشرين ثانية لم تنقضي بعد سيستمر في تنفيذ الأوامر الموجودة في هذه الحلقة
        while(et.isAlive())
        {
            num1 = (int)(Math.random()*10);             // num1 سيتم تخزين رقم عشوائي بين 1 و 9 في المتغير
            num2 = (int)(Math.random()*10);             // num2 سيتم تخزين رقم عشوائي بين 1 و 9 في المتغير
 
            System.out.print(num1+" + "+num2+" = ");    // num2 و num1 هنا سيطلب من المستخدم معرفة ناتج جمع العددين
            userAnswer = input.nextInt();               // هنا سيتم إنتظار المستخدم لإدخال الجواب
 
            if(userAnswer == num1+num2)                 // إذا كانت إجابته صحيحة, سيتم إضافة عدد الإجابات الصحيحة واحداً
                correctAnswersCounter++;
 
            else                                        // إذا كانت إجابته خاطئة, سيتم إضافة عدد الإجابات الخطأ واحداً
                wrongAnswersCounter++;
 
            operationsCounter++;                        // في الأخير سيتم إضافة عدد عمليات الجمع واحداً
        }
 
        System.out.println("Time end..\n");
 
        // بعد إنتهاء مدة العشرين ثانية سيتم طباعة عدد عمليات الجمع, عدد الأجوبة الصحيحة و عدد الأجوبة الخاطئة
        System.out.println("--------- Result --------");
        System.out.println("Number of operations:      " +operationsCounter);
        System.out.println("Number of correct answers: " +correctAnswersCounter);
        System.out.println("Number of wrong answers:   " +wrongAnswersCounter);
 
    }
 
}

عند تشغيل البرنامج, سنحصل على نتيجة تشبه النتيجة التالية عند التشغيل.
الأرقام التي قمنا بتعليمها باللون الأصفر هي التي قمنا بإدخالها عند تجربة البرنامج.

---------- Quiz ---------
0 + 8 = 8
5 + 7 = 11
8 + 8 = 16
6 + 6 = 12
3 + 9 = 12
7 + 4 = 14
9 + 4 = 13
Time end..

--------- Result --------
Number of operations: 7
Number of correct answers: 5
Number of wrong answers: 2

المثال الثالث

في المثال التالي قمنا تشغيل أكثر من كائن Thread في وقت واحد. الهدف هنا جعلك تدرك أن الأوامر لا تتنفذ فعلياً في وقت واحد لكنها تتنفذ بسرعة عالية جداً تجعل المستخدم يظن أنها تحدث في وقت واحد.

في البداية قمنا بإنشاء كلاس إسمه MyThread يرث من الكلاس Thread.
بعدها فعلنا Override للدالة run() حتى نجعل أي كائن من الكلاس MyThread يطبع إسمه كل ثانية.

ثم قمنا بإنشاء كلاس إسمه Main, و الذي قمنا فيه بإنشاء ثلاث كائنات من الكلاس MyThread و تشغيلهم مع بعض.

MyThread.java

public class MyThread extends Thread {
 
    // Thread كإسم لكائن الـ name و تمرير قيمة المتغير Thread سيتم مناداة الكونستركتور الذي ورثه من الكلاس MyThread عند إنشاء كائن من الكلاس
    public MyThread(String name) {
        super(name);
    }
 
 
    @Override
    public void run() {
 
        // true ترجع isInterrupted() طالما أن الدالة
        while (!this.isInterrupted())
        {
            // الذي قام بإستدعائها Thread سيتم طباعة إسم كائن الـ
            System.out.println(this.getName());
 
            // بعدها سيتم إيقافه مدة ثانية واحدة
            try {
                Thread.sleep(1000);
            }
            catch(Exception e) {
                System.out.println(e.getMessage());
            }
        }
 
    }
 
}

Main.java

public class Main {
 
    public static void main(String[] args) {
 
        // مع إعطاء كل واحد منهم إسم مختلف ( t1 - t2 - t3 ) إسمهم MyThread هنا قمنا بإنشاء ثلاث كائنات من الكلاس
        MyThread t1 = new MyThread("Thread 1");
        MyThread t2 = new MyThread("Thread 2");
        MyThread t3 = new MyThread("Thread 3");
 
        // كل ثانية ( t1 - t2 - t3 ) هنا قمنا بتشغيل جميع الكائنات, و بالتالي سيتم طباعة أسماء الكائنات
        t1.start();
        t2.start();
        t3.start();
 
    }

}

عند تشغيل البرنامج, نلاحظ أنه يطبع ثلاثة أسطر كل ثانية .

Thread 1
Thread 3
Thread 2

Thread 3
Thread 2
Thread 1

Thread 2
Thread 3
Thread 1

Thread 2
Thread 3
Thread 1

Thread 3
Thread 2
Thread 1
...

المثال الرابع

المثال التالي هو نفسه المثال السابق لكننا قمنا باستخدام الدالة run() بدلاً من الدالة start() حتى تعرف الفرق الحقيقي بينهما و ضرورة تشغيل كائن الـ Thread بواسطة الدالة start().

في البداية قمنا بإنشاء كلاس إسمه MyThread يرث من الكلاس Thread.
بعدها فعلنا Override للدالة run() حتى نجعل أي كائن من الكلاس MyThread يطبع إسمه ثم ينتظر مدة ثانية قبل أن يطبعه من جديد.

ثم قمنا بإنشاء كلاس إسمه Main, و الذي قمنا فيه بإنشاء ثلاث كائنات من الكلاس MyThread و تشغيلهم بواسطة الدالة run().

لاحظ كيف سيبقى البرنامج ينفذ أوامر أول كائن من الكلاس MyThread لأن الدالة run() تجعل البرنامج لا ينفذ أوامر أكثر من كائن Thread في وقت واحد.

MyThread.java

public class MyThread extends Thread {
 
    // Thread كإسم لكائن الـ name و تمرير قيمة المتغير Thread سيتم مناداة الكونستركتور الذي ورثه من الكلاس MyThread عند إنشاء كائن من الكلاس
    public MyThread(String name) {
        super(name);
    }
 
 
    @Override
    public void run() {
 
        // true ترجع isInterrupted() طالما أن الدالة
        while (!this.isInterrupted())
        {
            // الذي قام بإستدعائها Thread سيتم طباعة إسم كائن الـ
            System.out.println(this.getName());
 
            // بعدها سيتم إيقافه مدة ثانية واحدة
            try {
                Thread.sleep(1000);
            }
            catch(Exception e) {
                System.out.println(e.getMessage());
            }
        }
 
    }
 
}

Main.java

public class Main {
 
    public static void main(String[] args) {
 
        // مع إعطاء كل واحد منهم إسم مختلف ( t1 - t2 - t3 ) إسمهم MyThread هنا قمنا بإنشاء ثلاث كائنات من الكلاس
        MyThread t1 = new MyThread("Thread 1");
        MyThread t2 = new MyThread("Thread 2");
        MyThread t3 = new MyThread("Thread 3");
 
        // مع بعض ( t1 - t2 - t3 ) هنا حاولنا تشغيل الكائنات
        t1.run();       // آخر يعمل غيره Thread لأنه لا يوجد Thread سيتم تشغل هذا الـ
        t2.run();       // آخر يعمل قبله Thread لأنه يوجد Thread لن يتم تشغيل هذا الـ
        t3.run();       // آخر يعمل قبله Thread لأنه يوجد Thread لن يتم تشغيل هذا الـ
 
    }
 
}

عند تشغيل البرنامج, نلاحظ أنه يطبع ثلاثة أسطر كل ثانية .

Thread 1
Thread 1
Thread 1
Thread 1
Thread 1
Thread 1
Thread 1
Thread 1
Thread 1
Thread 1
Thread 1
Thread 1
Thread 1
Thread 1
Thread 1
Thread 1
Thread 1
Thread 1
...

المثال الخامس

في المثال التالي قمنا بإنشاء برنامج يظهر أمام المستخدم لائحة فيها أربع خيارات: تشغيل صوت التنبيه, إيقافه, إعادته للعمل, إيقافه نهائياً.
ميزة هذا البرنامج أنه يمكن تشغيل الإنذار أو إيقافه في نفس الوقت الذي يطلب فيه من المستخدم إدخال رقم الخيار.

في البداية قمنا بإنشاء كلاس إسمه Alert يرث من الكلاس Thread.
بعدها فعلنا Override للدالة start() لأننا لا نريد جعل البرنامج يعلق في حال قام المستخدم باستدعاء الدالة start() مرة ثانية.
فعلياً قلنا أن أي إستدعاء جديد للدالة start() بعد إستدعائها في المرة الأولى سيتم إستدعاء الدالة resume() بدلاً منها.

بعدها فعلنا Override للدالة run() حتى نجعل أي كائن من الكلاس Alert يصدر صوت تنبيه عند تشغيله.

ثم قمنا بإنشاء كلاس إسمه Main لتجربة الكلاس Alert.
عند تشغيل البرنامج ظهر لك أربع خيارات: تشغيل صوت التنبيه, إيقافه, إعادته للعمل, إيقافه نهائياً.
ستلاحظ أن البرنامج قادر على تشغيل صوت التنبيه في نفس الوقت الذي يطلب فيه من المستخدم إدخال رقم الخيار.

إنتبه: إرفع صوت الحاسوب إلا أعلا مستوى حتى تسمع صوت التنبيه عند تشغيله.

Alert.java

import java.awt.Toolkit;		// لأننا سنستخدمه للحصول على صوت التنبيه Toolkit هنا قمنا باستدعاء الكلاس
 
public class Alert extends Thread {
 
    // حتى نضمن أن لا يتم إستدعاءها مرتين start() سنستخدم هذا المتغير كشرط أساسي في الدالة
    private boolean isStarted = false;
 
 
    // start() للدالة Override هنا فعلنا
    @Override
    public void start() {
 
        // false تساوي isStarted إذا كانت قيمة المتغير
        if (isStarted == false) {
            // Thread و المسؤولة عن تشغيل كائن الـ Thread الموجودة في الكلاس start() سيتم إستدعاء الدالة
            // مرتين Thread التي تشغل كائن الـ start() حتى لا يتم تنفيذ الدالة isStarted بعدها سيتم تغيير قيمة المتغير
            super.start();
            isStarted = true;
        }
        else {
            resume();
        }
 
    }
 
 
    @Override
    public void run() {
 
        // true ترجع isInterrupted() طالما أن الدالة
        while (!this.isInterrupted())
        {
            // سيتم إصدار صوت المنبه كل ثانية
            try {
                Toolkit.getDefaultToolkit().beep();
                Thread.sleep(1000);
            }
            catch(Exception e) {
                System.out.println(e.getMessage());
            }
        }
 
    }
 
}

Main.java

import java.util.Scanner;		// Scanner هنا قمنا باستدعاء الكلاس
 
public class Main {
 
    public static void main(String[] args) {
 
        // و الذي سنستخدمه لإدخال بيانات من المستخدم input إسمه Scanner هنا قمنا بإنشاء كائن من الكلاس
        Scanner input = new Scanner(System.in);
 
        // سنستخدم هذا المتغير لتخزين العدد الذي سيدخله المستخدم
        int userInput;
 
        // alert إسمه Alert هنا قمنا بإنشاء كائن من الكلاس
        Alert alert = new Alert();
 
        // هنا قمنا بطباعة شكل لائحة من الخيارات أمام المستخدم
        System.out.println("----- Alert Menu ------\n"
                          +"| Enter (1) to Start  |\n"
                          +"| Enter (2) to Pause  |\n"
                          +"| Enter (3) to Resume |\n"
                          +"| Enter (4) to Stop   |\n"
                          +"-----------------------");
 
        // interrupt() بواسطة الدالة alert() هذه الحلقة تستمر في تنفيذ ما في داخلها طالما أنه لم يتم إيقاف الكائن
        while(!alert.isInterrupted())
        {
            // هنا سيتم إنتظار المستخدم ليدخل رقم الخيار الذي يريد
            System.out.print("User input >> ");
            userInput = input.nextInt();
 
            // هنا سيتم فحص القيمة التي أدخلها المستخدم
            switch(userInput)
            {
                // في حال قام بإدخال الرقم 1 سيتم تشغيل التنبيه
                case 1:
                    alert.start();
                    break;
 
                // في حال قام بإدخال الرقم 2 سيتم إيقاف التنبيه مع إمكانية تشغيله من جديد
                case 2:
                    alert.suspend();
                    break;
 
                // في حال قام بإدخال الرقم 3 سيتم إعادة التنبيه للعمل من جديد
                case 3:
                    alert.resume();
                    break;
 
                // في حال قام بإدخال الرقم 4 سيتم إيقاف التنبيه مع عدم إمكانية تشغيله من جديد
                case 4:
                    alert.interrupt();
                    alert.stop();
                    break;
 
                // في حال قام بإدخال رقم أكبر من 4 أو أصغر من واحد سيتم إظهار خطأ له
                default:
                    System.out.println("Option <"+userInput+"> Not Found!");
                    break;
            }
 
        }
 
    }

}

قم بتشغيل البرنامج و أدخل نفس القيم التي قمنا بتعليمها باللون الأصفر لتلاحظ كيف يعمل.
لا تنسى رفع صوت حاسوبك إلى أعلا مستوى حتى تسمع صوت التنبيه و هو يعمل.

عودة للدرس» «عودة للدرس

Java الكلاس `Thread` في جافا

مقدمة

بناؤه

خطوات بناء Thread بواسطة الكلاس `Thread`

مثال

خطوات إنشاء الـ `Thread` و تشغيله

مثال

الحالات التي يمر بها الـ `Thread` (Thread States)

كونستركتورات الكلاس `Thread`

دوال الكلاس `Thread`

أمثلة شاملة

المثال الأول

المثال الثاني

المثال الثالث

المثال الرابع

المثال الخامس

هدف الموقع

روابط مهمة

حقوق النشر

الدورات

أدوات مساعدة

أقسام الموقع

إبحث

Java الكلاس Thread في جافا

مقدمة

بناؤه

خطوات بناء Thread بواسطة الكلاس Thread

مثال

خطوات إنشاء الـ Thread و تشغيله

مثال

الحالات التي يمر بها الـ Thread (Thread States)

كونستركتورات الكلاس Thread

دوال الكلاس Thread

أمثلة شاملة

المثال الأول

المثال الثاني

المثال الثالث

المثال الرابع

المثال الخامس

هدف الموقع

روابط مهمة

حقوق النشر

الدورات

أدوات مساعدة

أقسام الموقع

إبحث

Java الكلاس `Thread` في جافا

خطوات بناء Thread بواسطة الكلاس `Thread`

خطوات إنشاء الـ `Thread` و تشغيله

الحالات التي يمر بها الـ `Thread` (Thread States)

كونستركتورات الكلاس `Thread`

دوال الكلاس `Thread`