פרויקט נול OpenJDK

1. סקירה כללית

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

2. פרויקט נול

Project Loom הוא ניסיון של קהילת OpenJDK להכניס לבניית Java מבנה מקבילי קל. אבות הטיפוס של Loom עד כה הכניסו שינוי ב- JVM כמו גם בספריית Java.

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

לפני שנדון במושגים השונים של Loom, בואו נדון במודל המקביליות הנוכחי ב- Java.

3. מודל המקבילות של ג'אווה

כַּיוֹם, פְּתִיל מייצג את הפשטת הליבה של המקבילות בג'אווה. הפשטה זו, יחד עם ממשקי API מקבילים אחרים מקלה על כתיבת יישומים מקבילים.

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

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

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

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

4. משימות ומתזמנים

כל יישום של חוט, קל משקל או כבד, תלוי בשתי קונסטרוקציות:

  1. משימה (המכונה גם המשך) - רצף הוראות שיכול להשעות את עצמו לצורך פעולת חסימה כלשהי
  2. מתזמן - להקצאת המשך למעבד ולהקצאת מעבד מחדש מהמשך מושהה

כַּיוֹם, Java מסתמכת על יישומי מערכת הפעלה הן להמשך והן לתזמן.

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

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

סוג זה של תזמון הוא לא אופטימלי ליישומי Java במיוחד.

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

Project Loom מציע לפתור זאת שרשורי מצב משתמש המסתמכים על יישום זמן ריצה של Java של המשכים ומתזמנים במקום הטמעת מערכת ההפעלה.

5. סיבים

באבות הטיפוס האחרונים ב- OpenJDK, שם חדש סִיב מוצג לספרייה לצד פְּתִיל מעמד.

מאז הספריה המתוכננת עבור סיבים דומה ל פְּתִיל, יישום המשתמש צריך להישאר דומה. עם זאת, ישנם שני הבדלים עיקריים:

  1. סִיב היה לעטוף כל משימה בהמשך פנימי למצב משתמש. זה יאפשר למשימה להשעות ולהתחדש בזמן ריצה של Java במקום הליבה
  2. מתזמן מצב משתמש ניתן לחיבור (ForkJoinPool, למשל) ישמש

בואו נעבור את שני הפריטים הללו בפירוט.

6. המשך

המשך (או שגרה משותפת) הוא רצף של הוראות שיכולות להניב ולהתחדש על ידי המתקשר בשלב מאוחר יותר.

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

חשוב להבין כי השעיה / קורות חיים אלה מתרחשים כעת בזמן הריצה של השפה במקום במערכת ההפעלה. לכן, זה מונע את המעבר ההקשר היקר בין נושאי הליבה.

בדומה לחוטים, Project Loom שואף לתמוך בסיבים מקוננים. מכיוון שסיבים מסתמכים על המשכים באופן פנימי, עליהם גם לתמוך בהמשך מקונן. כדי להבין זאת טוב יותר, שקול כיתה הֶמְשֵׁך המאפשר קינון:

המשך המשך 1 = חדש המשך (() -> {המשך המשך 2 = המשך חדש (() -> {// לעשות משהו להשעות (SCOPE_CONT_2); להשעות (SCOPE_CONT_1);});});

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

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

7. מתזמן

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

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

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

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

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

8. מסקנה

במאמר זה דנו בבעיות במודל המקביליות הנוכחי של Java ובשינויים שהציע Project Loom.

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


$config[zx-auto] not found$config[zx-overlay] not found