דוגמה לנושא Java Thread

ברוכים הבאים לדוגמא של תהליך ג'אווה. תהליך ו־תָּקָשִׁיָּה הם שני יחידות בסיסיות של ביצוע. תכנות קונקורנטי נעסק יותר בתהליכי ג'אווה.

תהליך

A process is a self contained execution environment and it can be seen as a program or application. However a program itself contains multiple processes inside it. Java runtime environment runs as a single process which contains different classes and programs as processes.

תָּקָשִׁיָּה

תָּקָשִׁיָּה ניתן לקרוא לה "תהליך קל משקל". תהליך דורש פחות משאבים ליצירה וקיים בתהליך, התהליך משתף את משאבי התהליך.

דוגמת תהליך ג'אווה

כל אפליקציה ב-Java מכילה לפחות תהליך אחד – התהליך הראשי. אף על פי שיש רבים תהליכים אחרים שרצים ברקע ב-Java כמו ניהול זיכרון, ניהול מערכת, עיבוד אותות וכו ', מבחינת היישום – הראשי הוא התהליך הראשון וניתן ליצור ממנו תהליכים נוספים. Multithreading מתייחס לשני או יותר תהליכים הרואים בביצוע ספציפי בתוך תכנית אחת. מעבד בלעדי לליבה בודדת יכול לבצע רק תהליך אחד בכל פעם ו-חתימת זמן היא תכונת המערכת הפעולה שמשתפת את זמן המעבד בין תהליכים ותהליכים שונים.

יתרונות התהליך ב-Java

1. תהליכי Java הם קלים לעומת תהליכים, זמן ומשאב פחותים נדרשים ליצירת תהליך.
2. התהליכים משתפים מידע וקוד של הורה שלהם
3. מעבר בין תהליכים נמשך נמוך בדרך כלל מאשר בין תהליכים.
4. תקשורת בין תהליכים פחות מורכבת מאשר תקשורת בין תהליכים.

Java מספקת שניים אמצעים ליצירת תהליך מתוכנת.

1. מיושם את הממשק java.lang.Runnable.
2. הרחבת המחלקה java.lang.Thread.

דוגמה לתהליך בתכנות Java – מיושם באמצעות ממשק Runnable

כדי להפוך מחלקה לניתנת להרצה, אנו יכולים ליישם את ממשק java.lang.Runnable ולספק ביצוע ב- public void run() שיטה. כדי להשתמש במחלקה זו כ Thread, נזדקק ליצירת אובייקט Thread על ידי מעבר אובייקט של מחלקת ה-Runnable הזו ולאחר מכן לקרוא ל- start() שיטה כדי לבצע את ה- run() שיטה בתהליך נפרד. הנה דוגמה לתהליך בתכנות Java על ידי המיושם ממשק Runnable.

package com.journaldev.threads;

public class HeavyWorkRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println("Doing heavy processing - START "+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
            // Get connection to the database, delete unused data from DB
            doDBProcessing();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Doing heavy processing - END "+Thread.currentThread().getName());
    }

    private void doDBProcessing() throws InterruptedException {
        Thread.sleep(5000);
    }

}

דוגמה לתהליך בתכנות Java – הרחבת מחלקת Thread

ניתן להרחיב את המחלקה java.lang.Thread כדי ליצור מחלקת תהליך Java משלנו ולדרוס את ה- run() שיטה. לאחר מכן אנו יכולים ליצור אותו כאובייקט ולקרוא ל- start() שיטה כדי לבצע את התהליך של מחלקת התהליך המותאמת שלנו. הנה דוגמה פשוטה לתהליך בתכנות Java המראה כיצד להרחיב את מחלקת Thread.

package com.journaldev.threads;

public class MyThread extends Thread {

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println("MyThread - START "+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
            // Get connection to the database, delete unused data from DB
            doDBProcessing();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("MyThread - END "+Thread.currentThread().getName());
    }

    private void doDBProcessing() throws InterruptedException {
        Thread.sleep(5000);
    }
    
}

הנה תוכנית בדיקה המראה כיצד ליצור תהליך Java ולהריץ אותו.

package com.journaldev.threads;

public class ThreadRunExample {

    public static void main(String[] args){
        Thread t1 = new Thread(new HeavyWorkRunnable(), "t1");
        Thread t2 = new Thread(new HeavyWorkRunnable(), "t2");
        System.out.println("Starting Runnable threads");
        t1.start();
        t2.start();
        System.out.println("Runnable Threads has been started");
        Thread t3 = new MyThread("t3");
        Thread t4 = new MyThread("t4");
        System.out.println("Starting MyThreads");
        t3.start();
        t4.start();
        System.out.println("MyThreads has been started");
        
    }
}

פלט של התוכנית לדוגמה של תהליך בתכנות Java מוצג למעלה:

Starting Runnable threads
Runnable Threads has been started
Doing heavy processing - START t1
Doing heavy processing - START t2
Starting MyThreads
MyThread - START Thread-0
MyThreads has been started
MyThread - START Thread-1
Doing heavy processing - END t2
MyThread - END Thread-1
MyThread - END Thread-0
Doing heavy processing - END t1

כשאנו מתחילים כל תהליך, תלותו בביצוע המערכת המבצעת חלוקת זמן, ואין לנו שליטה על ביצועם. עם זאת, ישנה אפשרות להגדיר עדיפות לתהליכים, אך גם כאשר זו נעשית, זאת אינה מבטיחה שהתהליך עם העדיפות הגבוהה יתבצע תחילה. הריצו את התוכנית למעלה מספר פעמים ותראו שאין דפוס קבוע של התחלה וסיום של תהליכים.

Runnable vs Thread

אם המחלקה שלך מספקת יותר פונקציות מאשר רק הרצת תהליך, יש לממש את ממשק ה-Runnable כדי לספק אמצעי להפעלתו כתהליך. אם המטרה היחידה של המחלקה היא לרוץ כתהליך, ניתן להרחיב את מחלקת Thread. המימוש של Runnable מועדף מכיוון שג'אווה תומכת במימוש של מספר ממשקים.עצה: כפי שהתבחרת, התהליך אינו מחזיר ערך, אך מה קורה אם נרצה שהתהליך יבצע עיבוד ויחזיר את התוצאה לתוכנית הלקוח? בדוק את Java Callable Future. עדכון: מ-Java 8 והלאה, הממשק Runnable הוא ממשק פונקציונלי וניתן להשתמש בביטויי למבד בכדי לספק את מימושו, במקום שימוש במחלקה אנונימית. למידע נוסף, ראה ממשקי פונקציות ב-Java 8.