רקעים רבים ב-Java – כל מה שחייבים לדעת

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

מהו רצת תהליכים מרובים?

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

רצת תהליכים מרובים נגד עיבוד מרובה

כשאנו מדברים על רצת תהליכים, אנחנו לא מתעניינים אם במחשב יש מעבד 2 ליבות או 16 ליבות. העבודה שלנו היא ליצור יישום רצת תהליכים ולתת למערכת ההפעלה לטפל בחלוקת המשאבים ובביצוע. בקיצור, רצת תהליכים אינה תלויה בעיבוד מרובה.

איך Java תומכת ברב-תהליכיות?

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

מהם סוגי התהליכים השונים?

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

מהו עדיפות התהליך?

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

כיצד ליצור תהליך ב-Java?

אנו יכולים ליצור תהליכים על ידי הממשק Runnable או על ידי הרחבת קלאס Thread.

Thread t = new Thread(new Runnable(){
    @Override
    public void run() {
    }
});

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

Runnable runnable = () -> System.out.println("Hello");

פעם שיצרנו תהליך, עלינו להתחיל את הרצתו על ידי קריאה לשיטת start().

runnable.start();

I have written a lot of posts explaining the concepts of multithreading in Java. You can go through these in sequence to learn everything about multithreading, its real-life usage, thread lifecycle, thread pool, etc.

1. תהליך Java ו-Runnable

אני אומר זאת וגם את זאת: זהו הפוסט הראשון על כיתת ה-Thread וממשק ה-Runnable. תלמד גם על תהליכים ותיקונים. מה ההבחנה בין Thread ל-Process? היתרונות בשימוש ב-Threads וכיצד ניתן ליצור Threads באמצעות ממשק ה-Runnable וכיתת ה-Thread. הפוסט גם משווה את ממשק ה-Runnable עם כיתת ה-Thread.

2. Java Thread Sleep

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

3. Java Thread Join

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

4. מצבי נושא ב-Java

הבנת מצבים שונים של נושא חשובה. למד כיצד נושא משנה את מצבו וכיצד לוחם הנושאים של מערכת ההפעלה משנה את מצבו של נושא.

5. המתנה, הודעה והודעה לכול בנושאים של Java

מחלקת Object ב-Java מכילה שלושה מתודות לתקשורת מצב הנעילה של משאב. למד באמצעות דוגמה שימוש במתודות אלו של מחלקת Object ביישום Wait-Notify פשוט.

6. בטיחות תהליכים וסנכרון

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

7. חריגה ב-Java בתהליך הראשי

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

8. אבטחת תהליכי תכנות בכיתת Singleton

במאמר זה, תלמדו מושגים בסיסיים ליצירת כיתת Singleton. מהם בעיות אבטחת התהליכים ביישומים שונים? כיצד אנו יכולים להשיג אבטחת תהליכים בכיתת Singleton.

9. תהליך רקע ב-Java

A simple article explaining daemon threads and how we can create daemon threads in java.

10. Thread Local ב-Java

אנחנו יודעים שתהליכים משתפים משתני Object, אך מה קורה אם רוצים ליצור משתנים אישיים לתהליכים שנוצרים ברמת הקלאס? בשפת ג'אווה קיימת מחלקת ה-ThreadLocal שמאפשרת יצירת משתנים אישיים לתהליכים. קרא כדי ללמוד כיצד ניתן ליצור משתנים מקומיים לתהליכים בתוכנית ג'אווה.

11.
שטח תהליכי ג'אווה

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

12.
איך לנתח מצבי סגירה מעגלית בג'אווה

הסגיר הוא מצב בו כמה תהליכים מחכים זה לזה לשחרר משאבים, יוצרים תלות מחזורית. מאמר זה דנה במצבים בהם יתכן שנתקל בסגיר בתוכנית Java. אנו נתאר כיצד ניתן להשתמש בהדפסת תהליכים (Thread dump) כדי לזהות סגיר, ובנוסף נסקור שיטות מומלצות למניעת סגיר בתוכנית Java.

13. Java Timer Thread

פוסט זה מסביר איך ניתן להשתמש במחובר זמן (Java Timer) ובמחלקת TimerTask כדי ליצור משימות שיתוף פעולה שירוץ בפרק זמן מתוזמן, יוצג דוגמה לתוכנית ואיך ניתן לבטל את הטיימר.

14. בעיה של יצרן וצרן ב-Java

לפני Java 5, ניתן היה לפתור את בעיה של יצרן וצרן באמצעות שימוש בשיטות wait() ו-notify(), אך עם הקדנות של BlockingQueue התהליך הפך להיות פשוט. למד כיצד ניתן להשתמש ב-BlockingQueue כדי לפתור את בעיה של יצרן וצרן ב-Java.

15. בריכת תהליכים של Java

בריכת תהליכים של Java היא אוסף של תהליכי עובד הממתינים לעיבוד משימות. הצגת המסגרת Executor של Java 5 קלה מאוד את יצירת בריכת תהליכים ב-Java. אנו יכולים להשתמש במחלקות Executors ו-ThreadPoolExecutor כדי ליצור ולנהל בריכת תהליכים.

16. Java Callable Future

לפעמים נרצה שהתהליך שלנו יחזיר ערכים שנוכל להשתמש בהם. ב-Java 5 ניתן להשתמש ב-Callable במקרה כזה, שדומה לממשק ה-Runnable. אנו יכולים להשתמש במסגרת ה-Executor כדי לבצע משימות Callable.

17. דוגמה ל-Java FutureTask

המחלקה FutureTask היא המחלקה הבטנית המיישמת את ממשק ה-Future. אנו משתמשים בה עם יישום Callable ו-Executors לעיבוד אסינכרוני. המחלקה FutureTask מספקת שיטות מימוש כדי לבדוק את מצב המשימה ולהחזיר את הערך לתוכנית הקוראת פעם אחת שסיימה את העיבוד שלה. זה מועיל כאשר ברצונך לדרוס חלק מהשיטות המימוש של ממשק ה-Future.

מסקנה

מתכנתת מרובות היא נושא מאוד רחב וכתיבת הכול עליו בפוסט יחיד לא היה אפשרי. אם תעבור דרך הפוסטים לעיל בסדרם, תלמד הכל על מתכנתת ב-Java.