ריבוי השחלות פנימה Java הוא תהליך של ביצוע שרשורים מרובים בו זמנית.
חוט הוא תת-תהליך קל משקל, יחידת העיבוד הקטנה ביותר. ריבוי עיבוד וריבוי השחלות, שניהם משמשים להשגת ריבוי משימות.
מה אומר xd
עם זאת, אנו משתמשים בריבוי השחלות מאשר בריבוי עיבודים מכיוון שרשורים משתמשים באזור זיכרון משותף. הם לא מקצים אזור זיכרון נפרד ולכן חוסך זיכרון, ומעבר ההקשר בין השרשורים לוקח פחות זמן מהתהליך.
Java Multithreading משמש בעיקר במשחקים, אנימציה וכו'.
היתרונות של Java Multithreading
1) זה לא חוסם את המשתמש מכיוון שהשרשורים הם עצמאיים וניתן לבצע מספר פעולות בו זמנית.
2) אתה יכול לבצע פעולות רבות ביחד, כך שזה חוסך זמן .
3) חוטים הם עצמאי , כך שזה לא משפיע על שרשורים אחרים אם מתרחש חריג בשרשור בודד.
ריבוי משימות
ריבוי משימות הוא תהליך של ביצוע משימות מרובות בו זמנית. אנו משתמשים בריבוי משימות כדי להשתמש במעבד. ניתן להשיג ריבוי משימות בשתי דרכים:
- ריבוי משימות מבוסס תהליכים (ריבוי עיבודים)
- ריבוי משימות מבוסס שרשור (Multithreading)
1) ריבוי משימות מבוסס תהליכים (ריבוי עיבודים)
- לכל תהליך יש כתובת בזיכרון. במילים אחרות, כל תהליך מקצה אזור זיכרון נפרד.
- תהליך הוא משקל כבד.
- עלות התקשורת בין התהליך גבוהה.
- מעבר מתהליך אחד למשנהו דורש זמן מה לשמירה וטעינה רושמת , מפות זיכרון, עדכון רשימות וכו'.
2) ריבוי משימות המבוססות על שרשורים (ריבוי נושאים)
- שרשורים חולקים את אותו מרחב כתובות.
- חוט הוא קל משקל.
- עלות התקשורת בין החוט נמוכה.
הערה: נדרש תהליך אחד לפחות עבור כל שרשור.
מה זה Thread ב-Java
חוט הוא תת-תהליך קל משקל, יחידת העיבוד הקטנה ביותר. זה נתיב נפרד של ביצוע.
השרשורים הם עצמאיים. אם יש חריגה בשרשור אחד, זה לא משפיע על שרשורים אחרים. הוא משתמש באזור זיכרון משותף.
כפי שמוצג באיור לעיל, חוט מבוצע בתוך התהליך. יש החלפת הקשר בין השרשורים. יכולים להיות תהליכים מרובים בתוך מערכת ההפעלה, ותהליך אחד יכול לכלול שרשורים מרובים.
הערה: בכל פעם שרשור אחד מבוצע בלבד.
שיעור Java Thread
Java מספקת שיעור חוטים כדי להשיג תכנות חוטים. שיעור חוטים מספק בנאים ושיטות ליצירה ולביצוע פעולות על שרשור. שיעור החוטים מתארך מחלקת אובייקט ומיישמת ממשק Runnable.
שיטות חוט ג'אווה
| S.N. | משנה וסוג | שיטה | תיאור |
|---|---|---|---|
| 1) | בָּטֵל | הַתחָלָה() | הוא משמש כדי להתחיל את ביצוע השרשור. |
| 2) | בָּטֵל | לָרוּץ() | הוא משמש לביצוע פעולה עבור שרשור. |
| 3) | ריק סטטי | לִישׁוֹן() | זה ישן שרשור למשך פרק הזמן שצוין. |
| 4) | חוט סטטי | currentThread() | היא מחזירה הפניה לאובייקט השרשור המופעל כעת. |
| 5) | בָּטֵל | לְהִצְטַרֵף() | זה מחכה לשרשור למות. |
| 6) | int | getPriority() | זה מחזיר את העדיפות של השרשור. |
| 7) | בָּטֵל | setPriority() | זה משנה את סדר העדיפויות של השרשור. |
| 8) | חוּט | getName() | זה מחזיר את שם השרשור. |
| 9) | בָּטֵל | setName() | זה משנה את שם השרשור. |
| 10) | ארוך | getId() | זה מחזיר את המזהה של השרשור. |
| אחד עשר) | בוליאני | בחיים() | זה בודק אם השרשור חי. |
| 12) | ריק סטטי | תְשׁוּאָה() | זה גורם לאובייקט השרשור המבצע כעת להשהות ולאפשר לשרשורים אחרים להפעיל באופן זמני. |
| 13) | בָּטֵל | לְהַשְׁעוֹת() | הוא משמש להשעיית החוט. |
| 14) | בָּטֵל | קורות חיים() | הוא משמש לחידוש החוט המושעה. |
| חֲמֵשׁ עֶשׂרֵה) | בָּטֵל | תפסיק() | הוא משמש לעצירת השרשור. |
| 16) | בָּטֵל | להרוס() | הוא משמש להרוס את קבוצת השרשור ואת כל תת הקבוצות שלה. |
| 17) | בוליאני | isDaemon() | זה בודק אם השרשור הוא שרשור דמון. |
| 18) | בָּטֵל | setDaemon() | זה מסמן את השרשור כדמון או שרשור משתמש. |
| 19) | בָּטֵל | פסיקת() | זה קוטע את השרשור. |
| עשרים) | בוליאני | isinterrupted() | זה בודק אם השרשור נקטע. |
| עשרים ואחת) | בוליאני סטטי | מוּפרָע() | זה בודק אם השרשור הנוכחי נקטע. |
| 22) | סטטי int | activeCount() | הוא מחזיר את מספר השרשורים הפעילים בקבוצת השרשור הנוכחי. |
| 23) | בָּטֵל | checkAccess() | זה קובע אם לשרשור הפועל כעת יש הרשאה לשנות את השרשור. |
| 24) | בוליאני סטטי | holdLock() | זה מחזיר אמת אם ורק אם השרשור הנוכחי מחזיק את נעילת הצג על האובייקט שצוין. |
| 25) | ריק סטטי | dumpStack() | הוא משמש להדפסת עקבות מחסנית של השרשור הנוכחי לזרם השגיאות הסטנדרטי. |
| 26) | StackTraceElement[] | getStackTrace() | הוא מחזיר מערך של רכיבי עקבות מחסנית המייצגים את מחסנית ה-Stack של החוט. |
| 27) | סטטי int | לִמְנוֹת() | הוא משמש להעתקת קבוצת השרשורים של כל שרשור פעיל ותת-הקבוצה שלו למערך שצוין. |
| 28) | שרשור.מדינה | getState() | הוא משמש להחזרת מצב השרשור. |
| 29) | קבוצת שרשורים | getThreadGroup() | הוא משמש להחזרת קבוצת השרשור שאליה שייך השרשור הזה |
| 30) | חוּט | toString() | הוא משמש להחזרת ייצוג מחרוזת של שרשור זה, כולל שם השרשור, העדיפות וקבוצת השרשור. |
| 31) | בָּטֵל | לְהוֹדִיעַ() | הוא משמש למתן הודעה עבור שרשור אחד בלבד שמחכה לאובייקט מסוים. |
| 32) | בָּטֵל | notifyAll() | הוא משמש למתן ההודעה לכל השרשורים הממתינים של אובייקט מסוים. |
| 33) | בָּטֵל | setContextClassLoader() | זה מגדיר את ההקשר ClassLoader עבור השרשור. |
| 3. 4) | ClassLoader | getContextClassLoader() | זה מחזיר את ההקשר ClassLoader עבור השרשור. |
| 35) | סטטי Thread.UncaughtExceptionHandler | getDefaultUncaughtExceptionHandler() | הוא מחזיר את מטפל ברירת המחדל שהופעל כאשר שרשור מסתיים בפתאומיות עקב חריג שלא נתפס. |
| 36) | ריק סטטי | setDefaultUncaughtExceptionHandler() | הוא מגדיר את המטפל המופעל כברירת מחדל כאשר שרשור מסתיים בפתאומיות עקב חריג שלא נתפס. |
- איך לבצע שתי משימות לפי שני חוטים?
- כיצד לבצע ריבוי שרשורים על ידי כיתה אנונימית?
- מהו מתזמן החוטים ומה ההבדל בין תזמון מנע לחיתוך זמן?
- מה קורה אם נפתח שרשור פעמיים?
- מה קורה אם נקרא למתודה run() במקום שיטת start()?
- מה המטרה של שיטת הצטרפות?
- מדוע JVM מפסיק את שרשור הדמון אם לא נותרו שרשורי משתמשים?
- מהו וו הכיבוי?
- מהו איסוף אשפה?
- מהי המטרה של שיטת finalize()?
- מה עושה שיטת gc()?
- מהו סנכרון ולמה להשתמש בסנכרון?
- מה ההבדל בין שיטה מסונכרנת לבלוק מסונכרן?
- מהן שתי הדרכים לבצע סנכרון סטטי?
- מהו מבוי סתום ומתי הוא יכול להתרחש?
- מהי תקשורת בין חוטים או שיתוף פעולה?
- ריבוי השחלות
- מחזור חיים של חוט
- שתי דרכים ליצור שרשור
- כיצד לבצע משימות מרובות לפי שרשורים מרובים
- מתזמן שרשורים
- ישן חוט
- אפשר לפתוח שרשור פעמיים?
- מה קורה אם נקרא למתודה run() במקום שיטת start()?
- מצטרף לשרשור
- מתן שם לשרשור
- עדיפות של חוט
- חוט דימון
- ShutdownHook
- איסוף זבל
- סנכרון בשיטה מסונכרנת
- בלוק מסונכרן
- סנכרון סטטי
- מָבוֹי סָתוּם
- תקשורת בין חוטים