דלגו לתוכן הראשי
גאמא קוד

High Level Programming

Reflection Garbage Collector Mutex

רפלקציה, Garbage Collector, נעילות ו-Mutex בעבודה עם שרשורים ב-Java וב-C#.

בחרו את הרמה שמתאימה לכם ואת הסט שתרצו לתרגל

חומר לימוד

Reflection Garbage Collector Mutex: שלושה שירותים של סביבת הריצה

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

  • Reflection: איך תוכנית מגלה בזמן ריצה אילו מחלקות, מתודות ושדות יש לה, מפעילה אותם לפי שם, ומה זה עולה לה.
  • Garbage Collector: איך סביבת הריצה מזהה אובייקטים שכבר אי אפשר להגיע אליהם ומפנה את הזיכרון שלהם בעצמה, ומה בכל זאת יכול לדלוף.
  • Mutex: מנעול שדואג שבכל רגע רק שרשור (thread) אחד ייגע בנתונים משותפים, ואיך כותבים נעילה כזו ב-Java וב-C#.

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

כל דוגמה שמוצג לצדה פלט הורצה בפועל (Java 8 ו-.NET 7), והפלט הוא מה שהתקבל, כולל הודעות השגיאה של המהדר.

מה צריך להכיר מראש: מחלקה ואובייקט, שדה ומתודה, static, ירושה בסיסית ו-try / catch / finally. כשלא כתוב באיזו שפה הקוד, הוא Java.

Reflection: כשהתוכנית חוקרת את המבנה של עצמה

מה רפלקציה עושה ומאיפה היא שואבת את המידע

כשאתם כותבים invoice.total(), כל הפרטים ידועים כבר כשהמהדר עובר על הקובץ. הוא מוודא שהמחלקה קיימת, שיש לה מתודה total בלי פרמטרים, ושהרשאת הגישה שלה מתירה לכם לקרוא לה; אם משהו לא מסתדר, הקוד פשוט לא מתקמפל.

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

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

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

תרחיש 1: מנוע בדיקות שלא מכיר את הבדיקות שלכם

מנוע הבדיקות הגיע אליכם כקובץ jar מוכן. רק אחר כך כתבתם מחלקה בשם CartTests עם מתודה discountApplied.

בתוך ה-jar אין שורה שמזכירה את CartTests, וגם לא יכולה להיות: המנוע נבנה לפני שהשם הזה היה קיים. הנה מה שהוא עושה במקום:

  1. מקבל את השם CartTests כמחרוזת, למשל משורת הפקודה.
  2. מבקש מה-JVM את אובייקט ה-Class שמתאים לשם הזה.
  3. שואל את האובייקט אילו מתודות יש במחלקה, ובודק על כל אחת אם סומנה כבדיקה.
  4. מפעיל את המסומנות, אחת אחרי השנייה.

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

ומאיפה המנוע יודע ש-CartTests מכילה מתודה בשם discountApplied? מהקובץ CartTests.class.

כשהמהדר תרגם את המחלקה שלכם, הוא הוסיף לקובץ, לצד ההוראות עצמן, תיאור שלה: מטא-דאטה (metadata) עם השם שלה, שמות השדות והמתודות, סוגי הפרמטרים והאנוטציות. ב-.NET אותו תיאור נשמר בתוך ה-assembly.

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

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

אותה סביבת ריצה מטפלת גם בזיכרון: היא עוקבת אחרי האובייקטים שעדיין בשימוש ומפנה את השאר, וזה איסוף האשפה שנלמד בהמשך. סביבת הריצה היא לא מתרגם חד-פעמי לשפת מכונה, אלא שכבה שעובדת לאורך כל הריצה. שני השירותים שלה שנפגוש כאן הם ניהול זיכרון אוטומטי ומידע חי על המחלקות והאובייקטים.
נושאJavaC#
האובייקט שמתאר טיפוסjava.lang.ClassSystem.Type
איפה יושבות מחלקות הרפלקציההחבילה java.lang.reflectמרחב השמות System.Reflection
אובייקטים שמייצגים חבריםMethod, Field, ConstructorMethodInfo, FieldInfo, ConstructorInfo, PropertyInfo
מקור המידעה-JVM, שקוראת את קובצי ה-classה-CLR, שקורא את ה-assembly

נניח שמשתמש מקליד בחלון הניהול את הטקסט cart.clear(). בשפת סקריפט, eval היה מפענח את הטקסט כקוד ומריץ אותו. רפלקציה לא יודעת לעשות את זה; מה שהיא כן יודעת הוא לקבל את המילה clear, למצוא במחלקה המהודרת מתודה בשם הזה ולהפעיל אותה.

ועכשיו ספריית JSON שכותבת את Order לקובץ. ההמרה לטקסט, והקריאה חזרה, היא serialization, והיא העבודה של הספרייה. רפלקציה היא רק הכלי שבעזרתו הספרייה מגלה ש-Order מחזיקה שדות id ו-paid.

טעויות נפוצות
  • רפלקציה היא שלב שבו המהדר מנתח את מבנה המחלקות לפני ההרצה. היא פועלת כשהתוכנית כבר רצה, על המטא-דאטה שסביבת הריצה טענה לזיכרון. המהדר רק כותב את המטא-דאטה לקובץ.
  • רפלקציה מקבלת קוד כמחרוזת ומריצה אותו. זה תיאור של eval. רפלקציה מאתרת ומפעילה מתודות, שדות ובנאים שכבר קומפלו.
  • רפלקציה פירושה לשמור אובייקט בקובץ או לשלוח אותו ברשת. זו serialization. רפלקציה היא כלי שספריות כאלה נעזרות בו כדי לגלות את השדות, לא ההמרה עצמה.
  • התפקיד של סביבת הריצה נגמר כשהיא מתרגמת את הקוד לשפת מכונה. היא פעילה לאורך כל הריצה: מנהלת זיכרון ומפנה אובייקטים שאין בהם שימוש, ועונה לשאלות רפלקציה על מחלקות ואובייקטים. היא גם לא מפרשת קוד מקור שורה אחר שורה ולא שומרת את האובייקטים על הדיסק.
בדקו את עצמכם
ספריית לוגים מדפיסה כל אובייקט בצורה Order{id=7, paid=true}, בלי שכתבתם toString ובלי שהספרייה מכירה את Order. מה מאפשר לה לדעת שיש שדות id ו-paid?

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

האם קוד רפלקציה יכול להציג את ההערות (comments) שהמתכנת כתב מעל מתודה?

לא. ההערות נשארות בקובץ ה-java, ורפלקציה קוראת רק את המטא-דאטה שבקובצי ה-class, ושם אין להן זכר.

חזרה לתוכן העניינים

אובייקט Class: שלוש דרכים להשיג אותו, וטעינה לפי שם

נקודת הפתיחה של כל פעולת רפלקציה ב-Java היא אובייקט מטיפוס java.lang.Class. לכל מחלקה טעונה יש אובייקט כזה, והוא יודע לענות על שאלות על המבנה שלה.

הדרךמתי משתמשים בההערה
obj.getClass()כשיש בידכם אובייקטמתודה שמוגדרת ב-Object, ולכן קיימת בכל אובייקט
Foo.classכששם המחלקה ידוע כבר כשכותבים את הקודביטוי של השפה שבא אחרי שם של טיפוס; אחרי שם של משתנה הוא לא מתקמפל
Class.forName("pkg.Foo")כשהשם מגיע כמחרוזת בזמן ריצה, למשל מקובץ הגדרותטוענת את המחלקה אם היא עוד לא בזיכרון

ב-C# אותן שלוש דרכים הן obj.GetType(), typeof(Foo) ו-Type.GetType("Ns.Foo"). שימו לב לאות הגדולה: GetType שייכת ל-C#, וב-Java המתודה היא getClass.

הדוגמה הבאה משתמשת בשלוש הדרכים, ולמחלקה Codec יש גם בלוק סטטי וגם בנאי שמדפיסים הודעה, כדי שנראה בדיוק מתי כל אחד מהם רץ:

Java
class Codec {
    static { System.out.println("Codec: static init"); }
    Codec() { System.out.println("Codec: new object"); }
}

public class App {
    public static void main(String[] cli) throws Exception {
        StringBuilder trail = new StringBuilder(64);
        Class<?> fromObject = trail.getClass();          // ask an existing object
        Class<?> fromLiteral = StringBuilder.class;      // a class literal in the source
        System.out.println(fromObject.getName() + " same=" + (fromObject == fromLiteral));

        Class<?> first = Class.forName("Codec");         // name known only at run time
        Class<?> again = Class.forName("Codec");         // already loaded: no second init
        System.out.println("forName twice, same=" + (first == again));

        Object codec = first.getDeclaredConstructor().newInstance();
        System.out.println("instance of " + codec.getClass().getSimpleName());

        try {
            Class.forName("Codek");                      // misspelled name
        } catch (ClassNotFoundException e) {
            System.out.println("caught " + e.getClass().getSimpleName() + " for " + e.getMessage());
        }
    }
}
פלט
java.lang.StringBuilder same=true
Codec: static init
forName twice, same=true
Codec: new object
instance of Codec
caught ClassNotFoundException for Codek

השורה הראשונה מראה ש-getClass() ו-StringBuilder.class מחזירים את אותו אובייקט בדיוק. המעניין מתחיל בשורה השנייה: Codec: static init הודפסה בתוך הקריאה הראשונה ל-forName, והקריאה השנייה לא הדפיסה דבר.

מה שקרה שם נקרא טעינה ואתחול. ה-JVM חיפשה את Codec ב-classpath, כלומר ברשימת התיקיות וקובצי ה-jar שבהם היא מחפשת מחלקות, קראה אותה לזיכרון, והריצה את הקוד הסטטי שלה: בלוקי static { } וערכים התחלתיים של שדות static. מחלקה מאותחלת פעם אחת, ולכן הקריאה השנייה קיבלה את אותו אובייקט Class (same=true) בלי שום הדפסה.

עכשיו שימו לב מה לא הודפס בין שתי הקריאות: הודעת הבנאי. היא הופיעה רק אחרי getDeclaredConstructor().newInstance(), הצעד הנפרד שיוצר מופע. forName לא בונה אובייקט ולא מגיעה ל-main של המחלקה (ל-newInstance של Class עצמו, הצורה הישנה, הוצמד סימון deprecated ב-Java 9).

השורה האחרונה מראה מה קורה כשהשם לא נמצא: Class.forName זורקת ClassNotFoundException בשורה שניסתה לטעון אותו. היא לא מחזירה null ולא מחפשת שם קרוב.

החריגה הזו היא checked exception, ולכן המהדר דורש שקריאה ל-forName תתפוס אותה או תצהיר עליה ב-throws.

ומה אם כותבים .class אחרי משתנה? המהדר מחפש טיפוס בשם הזה ולא מוצא:

Java
public class App {
    public static void main(String[] cli) {
        StringBuilder memo = new StringBuilder(16);
        Class<?> c = memo.class;   // a class literal needs a type name, not a variable
    }
}
פלט
App.java:4: error: cannot find symbol
        Class<?> c = memo.class;   // a class literal needs a type name, not a variable
                     ^
  symbol:   class memo
  location: class App
1 error
ה-JVM לא סורקת קובצי הגדרות כשהתוכנית עולה. מבחינתה שם של מחלקה בקובץ הוא סתם מחרוזת, ושם שגוי יתגלה רק ברגע שמישהו ינסה לטעון אותו.

ב-C# ההתנהגות הפוכה: Type.GetType עם שם שלא קיים מחזירה null ולא זורקת. בנוסף, לטיפוס שנמצא ב-assembly אחר (לא זה שקורא לה ולא ספריית הליבה) צריך להעביר שם מלא שכולל גם את שם ה-assembly.

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

Java
public class App {
    // true when the named class can be loaded right now
    static boolean onClasspath(String className) {
        try {
            Class.forName(className);
            return true;
        } catch (ClassNotFoundException e) {
            return false;
        }
    }

    public static void main(String[] cli) {
        System.out.println("CRC32 available: " + onClasspath("java.util.zip.CRC32"));
        System.out.println("PDF export available: " + onClasspath("org.acme.pdf.PdfExporter"));
    }
}
פלט
CRC32 available: true
PDF export available: false

שימו לב שהקובץ התקמפל, אף שאין בשום מקום מחלקה בשם org.acme.pdf.PdfExporter. בזה כל העניין: השם יושב בתוך מרכאות, ולכן המהדר לא מחפש אותו. אילו הייתם כותבים import org.acme.pdf.PdfExporter או new PdfExporter(), הבנייה הייתה נכשלת עוד אצלכם, וגם instanceof היה דורש את המחלקה כבר בהידור.

וכשהתשובה היא true, ממשיכים באותה דרך: מבקשים מאובייקט ה-Class את המתודה הדרושה ומפעילים אותה דרך Method. כך מפעילים קוד של jar שהונח ב-classpath, בלי שקוד המקור שלו נוסף לפרויקט שלכם ובלי שהמהדר שלכם ראה אותו אי פעם.

תרחיש 2: תוסף ששמו נכתב לא נכון

בקובץ app.properties כתוב exporter=com.office.CsvExpoter, בלי האות r השנייה.

  1. התוכנית עולה בלי שום תלונה, כי אף אחד לא בודק את תוכן הקובץ מראש.
  2. משתמש מבקש ייצוא, והקוד מגיע ל-Class.forName(props.getProperty("exporter")).
  3. ה-JVM מחפשת את השם ב-classpath ולא מוצאת מחלקה כזו.
  4. נזרקת ClassNotFoundException, בדיוק בשורה הזו.

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

טעויות נפוצות
  • Class.forName מחזירה אובייקט חדש שנבנה בבנאי בלי פרמטרים. היא מחזירה את אובייקט ה-Class, אחרי טעינה ואתחול. אובייקט של המחלקה נוצר רק כשקוראים ל-newInstance על הבנאי.
  • forName טוענת את המחלקה, אבל הבלוק הסטטי ממתין עד שמישהו ייצור מופע. forName מאתחלת את המחלקה מיד, ולכן הקוד הסטטי רץ כבר בתוך הקריאה עצמה.
  • טעינה לפי שם מפעילה גם את main של המחלקה. main רצה רק במחלקה שנבחרה כנקודת הכניסה כשהתוכנית מתחילה. טעינה לא קוראת לה.
  • כשהמחלקה חסרה, forName מחזירה null. ב-Java נזרקת ClassNotFoundException. null מקבלים דווקא מ-Type.GetType ב-C#.
  • אפשר לבדוק אם מחלקה קיימת בעזרת instanceof, או בעזרת import ו-catch. גם instanceof וגם import מזכירים את המחלקה בקוד, ולכן המהדר צריך אותה כבר בבנייה. רק שם שמגיע כמחרוזת דוחה את הבדיקה לזמן ריצה.
בדקו את עצמכם
במחלקה Registry יש שדה static int loads = count();, ו-count מדפיסה counting. התוכנית קוראת שלוש פעמים ל-Class.forName("Registry"). כמה פעמים יודפס counting?

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

קוד קורא ל-Class.forName("billing.Invoice") ולא עושה עם התוצאה שום דבר נוסף. הבנאי של Invoice מדפיס הודעה. האם היא תודפס?

לא. רק החלק הסטטי של המחלקה רץ, בזמן האתחול. הבנאי רץ כשיוצרים מופע, למשל ב-getDeclaredConstructor().newInstance(), וזה לא קרה כאן.

חזרה לתוכן העניינים

חברי המחלקה: מציאה, הפעלה ויצירה

אובייקט Class הוא שער לאובייקטים נוספים, אחד לכל חבר במחלקה: Method, Field ו-Constructor, כולם מהחבילה java.lang.reflect.

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

קריאההרשאות שנכללותגם מה שעבר בירושה?
getMethods(), getFields()public בלבדכן, מכל מחלקות האב ומהממשקים
getDeclaredMethods(), getDeclaredFields()כולן, גם privateלא, רק מה שכתוב במחלקה הזו
getMethod(name, types...), getField(name)public בלבדכן
getDeclaredMethod(name, types...), getDeclaredField(name)כולןלא
איך זוכרים: Declared פירושו "מה שהמחלקה הזו הכריזה עליו בעצמה", בלי שום קשר להרשאה. בלי Declared מקבלים את הפנים הציבוריות של המחלקה כפי שהעולם רואה אותן, כולל מה שירשה.

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

Java
import java.lang.reflect.Field;
import java.lang.reflect.Member;
import java.util.Arrays;

class Sensor {
    public int id;
    private long lastPing;
    public void calibrate() { }
    private void reset() { }
}

class Thermometer extends Sensor {
    public String unit;
    private double offset;
    public double read() { return 0; }
    private void warmUp() { }
}

public class App {
    // sorted names, skipping members that come from Object
    static String names(Member[] members) {
        return Arrays.toString(Arrays.stream(members)
            .filter(m -> m.getDeclaringClass() != Object.class)
            .map(Member::getName).sorted().toArray());
    }

    public static void main(String[] cli) {
        Class<?> t = Thermometer.class;
        System.out.println("methods          " + names(t.getMethods()));
        System.out.println("declared methods " + names(t.getDeclaredMethods()));
        System.out.println("fields           " + names(t.getFields()));
        System.out.println("declared fields  " + names(t.getDeclaredFields()));
        System.out.println("parent declares  " + names(t.getSuperclass().getDeclaredMethods()));
    }
}
פלט
methods          [calibrate, read]
declared methods [read, warmUp]
fields           [id, unit]
declared fields  [offset, unit]
parent declares  [calibrate, reset]

הפלט מאשר את הטבלה. getMethods הביאה את read של המחלקה ואת calibrate שירשה, ודילגה על שתי המתודות הפרטיות. getDeclaredMethods הביאה את read ואת warmUp הפרטית, אבל לא את calibrate, כי היא כתובה ב-Sensor.

השדות מתנהגים בדיוק כך, ומי שצריך את מה ש-Sensor הכריזה עליו שואל את getSuperclass(). הסינון של Object נועד רק לקצר את הפלט: בלעדיו getMethods הייתה מחזירה גם את toString, equals, hashCode ושאר המתודות הציבוריות של Object.

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

Java
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

class Discount {
    public double apply(double price) { return price * 0.9; }
    public static String currency() { return "ILS"; }
    public void setPercent(int pct) {
        if (pct > 100) throw new IllegalArgumentException("pct over 100: " + pct);
    }
}

public class App {
    public static void main(String[] cli) throws Exception {
        Class<?> type = Class.forName("Discount");
        Object d = type.getDeclaredConstructor().newInstance();

        Method apply = type.getMethod("apply", double.class);
        double paid = (Double) apply.invoke(d, 50.0);         // result comes back as Object
        System.out.println("paid " + paid);

        System.out.println("currency " + type.getMethod("currency").invoke(null));  // static

        Method setter = type.getMethod("setPercent", int.class);
        try {
            setter.invoke(d, 140);                            // the method itself throws
        } catch (InvocationTargetException e) {
            System.out.println("outer: " + e.getClass().getName());
            System.out.println("inner: " + e.getCause().getMessage());
        }

        try {
            apply.invoke(d, "fifty");                          // wrong argument type
        } catch (IllegalArgumentException e) {
            System.out.println("refused by invoke: " + e.getMessage());
        }

        try {
            type.getMethod("aply", double.class);             // misspelled name
        } catch (NoSuchMethodException e) {
            System.out.println("lookup failed: " + e.getMessage());
        }
    }
}
פלט
paid 45.0
currency ILS
outer: java.lang.reflect.InvocationTargetException
inner: pct over 100: 140
refused by invoke: argument type mismatch
lookup failed: Discount.aply(double)
שורה בפלטמה קרההכלל שעומד מאחוריה
paid 45.0invoke(d, 50.0) הריצה את apply על האובייקט dהתוצאה חוזרת כ-Object (כאן Double ארוז), ובלי cast אי אפשר להתייחס אליה כ-double
currency ILScurrency סטטית, ולכן הועבר null במקום אובייקטמתודה static לא שייכת לאף מופע
outer ו-innersetPercent רצה וזרקה בעצמהמה שמגיע ל-catch הוא InvocationTargetException, והחריגה המקורית מחכה ב-getCause()
refused by invokeביקשנו להעביר מחרוזת לפרמטר מסוג doubleinvoke דוחה את הבקשה לפני שהמתודה מתחילה, ב-IllegalArgumentException לא עטופה
lookup failedחיפשנו מתודה בשם aplyשם שאין מאחוריו חבר: NoSuchMethodException למתודה, NoSuchFieldException לשדה

את האובייקט עצמו בנתה השורה השנייה של main: getDeclaredConstructor() החזירה את הבנאי בלי הפרמטרים, ו-newInstance הפעילה אותו. לבנאי עם פרמטרים מעבירים את סוגיהם ל-getDeclaredConstructor ואת הערכים ל-newInstance.

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

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

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

ב-C# אותם רעיונות, בשמות אחרים. MethodInfo.Invoke עוטפת חריגה של המתודה ב-TargetInvocationException, והמקורית יושבת ב-InnerException. Activator.CreateInstance בונה אובייקט מתוך Type, ואת החברים הלא ציבוריים מוצאים רק כשמוסיפים לחיפוש את הדגלים BindingFlags.NonPublic | BindingFlags.Instance.

C#
using System;
using System.Reflection;

class Locker
{
    private string code = "7Q";
    public void Open() { throw new InvalidOperationException("locker jammed"); }
}

class Program
{
    static void Main()
    {
        Type byLiteral = typeof(Locker);
        Type byObject = new Locker().GetType();
        Console.WriteLine(byObject.Name + " same=" + (byLiteral == byObject));

        Type missing = Type.GetType("Storage.Lockr");          // misspelled, no exception
        Console.WriteLine("lookup result is null: " + (missing == null));

        object box = Activator.CreateInstance(byLiteral);       // create from a Type
        FieldInfo hidden = byLiteral.GetField("code", BindingFlags.NonPublic | BindingFlags.Instance);
        Console.WriteLine("hidden code: " + hidden.GetValue(box));
        Console.WriteLine("without NonPublic: " + (byLiteral.GetField("code") == null));

        try
        {
            byLiteral.GetMethod("Open").Invoke(box, null);
        }
        catch (TargetInvocationException e)
        {
            Console.WriteLine(e.GetType().Name + " -> " + e.InnerException.Message);
        }
    }
}
פלט
Locker same=True
lookup result is null: True
hidden code: 7Q
without NonPublic: True
TargetInvocationException -> locker jammed

שימו לב לשורה השנייה: שם שגוי ב-Type.GetType החזיר null בשקט. ובשורה הרביעית: בלי BindingFlags.NonPublic, GetField לא מוצאת את השדה הפרטי ומחזירה null.

תרחיש 3: שתי המשפחות מול מחלקה יורשת

המחלקה Account מגדירה public deposit(). המחלקה SavingsAccount יורשת ממנה ומוסיפה public addInterest() ו-private roundCents().

קריאה על SavingsAccount.classמה חוזר (בלי המתודות של Object)למה
getMethods()addInterest, depositשתיהן ציבוריות, ו-deposit נכללת כי עברה בירושה
getDeclaredMethods()addInterest, roundCentsשתיהן כתובות ב-SavingsAccount, בלי קשר להרשאה

כדי למצוא את deposit דרך משפחת Declared צריך לשאול את Account.class, או לטפס אליה מ-SavingsAccount.class עם getSuperclass().

טעויות נפוצות
  • getDeclaredMethods מחזירה גם את מה שהמחלקה ירשה. היא מחזירה רק את מה שכתוב במחלקה שעליה נקראה. את מחלקת האב שואלים בנפרד.
  • רפלקציה עיוורת למתודות של מחלקת האב. getMethods כוללת את המתודות הציבוריות שעברו בירושה, ו-getSuperclass() פותחת את כל מה שהאב הכריז עליו.
  • getFields מחזירה גם שדות פרטיים. היא מחזירה רק שדות ציבוריים. שדה פרטי מוצאים עם getDeclaredField.
  • חריגה שמתודה זורקת בתוך invoke מגיעה לקורא כמו בקריאה רגילה. היא מגיעה עטופה ב-InvocationTargetException, ואת המקורית שולפים ב-getCause().
  • כדי לייצר מופע ברפלקציה משכפלים את המחלקה עם clone(). clone מעתיק אובייקט שכבר קיים, ורק במחלקה שמממשת Cloneable. יצירה ברפלקציה היא getDeclaredConstructor().newInstance().
בדקו את עצמכם
מתודה סטטית ratio() הופעלה עם m.invoke(null), ובתוכה התבצעה חלוקה של int באפס. איזו חריגה יתפוס הקורא, ואיך יגיע לחריגה שקרתה בפועל?

InvocationTargetException. החריגה המקורית, ArithmeticException, נמצאת ב-getCause() שלה.

במחלקה Printer יש private void purgeQueue(). מה יקרה בחיפוש Printer.class.getMethod("purgeQueue"), ואיזה חיפוש כן ימצא אותה?

החיפוש ייכשל ב-NoSuchMethodException, כי getMethod רואה רק מתודות ציבוריות. getDeclaredMethod("purgeQueue") תמצא אותה, כי היא הוכרזה ב-Printer עצמה.

חזרה לתוכן העניינים

חברים פרטיים: setAccessible ומה זה עושה לכימוס

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

Java
class Badge {
    private String owner = "Noa";
}

public class App {
    public static void main(String[] cli) {
        Badge b = new Badge();
        System.out.println(b.owner);   // direct access from another class
    }
}
פלט
App.java:8: error: owner has private access in Badge
        System.out.println(b.owner);   // direct access from another class
                            ^
1 error

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

רפלקציה יודעת לעקוף את המגבלה, בשלושה צעדים:

  1. משיגים את אובייקט ה-Field עם getDeclaredField("name"). getField לא תעזור כאן, כי היא מוצאת רק שדות ציבוריים.
  2. מכבים את בדיקת הגישה של אותו אובייקט: field.setAccessible(true).
  3. קוראים עם field.get(obj) או כותבים עם field.set(obj, value).

הצעד השני לא קורה מעצמו. ברירת המחדל של רפלקציה היא לכבד הרשאות, ולכן get על שדה פרטי לפני setAccessible זורקת IllegalAccessException.

Java
import java.lang.reflect.Field;

class Badge {
    private String owner = "Noa";
    private int level = 3;
}

public class App {
    public static void main(String[] cli) throws Exception {
        Badge b = new Badge();
        Field owner = Badge.class.getDeclaredField("owner");
        Field level = Badge.class.getDeclaredField("level");

        try {
            owner.get(b);                                // the check is on by default
        } catch (IllegalAccessException e) {
            System.out.println("before: IllegalAccessException");
        }

        owner.setAccessible(true);                       // only this Field object is opened
        System.out.println("owner = " + owner.get(b));
        owner.set(b, "Omer");                            // writing works too
        System.out.println("owner = " + owner.get(b));

        try {
            level.get(b);                                // a different Field, still checked
        } catch (IllegalAccessException e) {
            System.out.println("level: IllegalAccessException");
        }

        try {
            Badge.class.getField("owner");               // getField sees public fields only
        } catch (NoSuchFieldException e) {
            System.out.println("getField: NoSuchFieldException");
        }
    }
}
פלט
before: IllegalAccessException
owner = Noa
owner = Omer
level: IllegalAccessException
getField: NoSuchFieldException

הפלט מלמד שלושה דברים. לפני הפתיחה נזרקה חריגה; אחרי הפתיחה אפשר היה גם לקרוא וגם לכתוב; והשדה level, שאובייקט ה-Field שלו לא נפתח, נשאר חסום אף שהוא באותה מחלקה.

המקרה של level מראה שהפתיחה היא תכונה של אובייקט ה-Field, לא של השדה ולא של המחלקה. אותו דבר ב-Method וב-Constructor: כל אובייקט נפתח לעצמו, ושום דבר אחר בתוכנית לא מושפע.

הסתכלו גם על הארגומנט בקריאה owner.get(b). לכל Badge יש owner משלו, כי השדה אינו static, ולכן הקריאה חייבת לדעת באיזה Badge מדובר. שדה משותף לכל המופעים הוא עניין של static, ומגדיר הגישה private לא משנה בזה דבר.

ובקובץ App.java עדיין כתוב private String owner, וגם בקובץ ה-class. מה שהשתנה הוא מצב בזיכרון של אובייקט Field אחד, בזמן הריצה.

על המחלקות של האפליקציה הפתיחה עובדת כמו בדוגמה. מ-Java 16 ה-JDK מוסיף strong encapsulation לחבילות הפנימיות שלו: מי שקורא ל-setAccessible על חבר בחבילה שהמודול שלה לא נפתח מקבל InaccessibleObjectException. הדוגמאות כאן רצו על Java 8, שבה המגבלה עוד לא קיימת.
תרחיש 4: בדיקה שמציצה לשדה בלי getter

במחלקה RateLimiter יש private int remaining = 100, ואין מתודה שמחזירה אותו. הבדיקה רוצה לוודא שאחרי שלוש בקשות נשארו 97, בלי להוסיף ל-RateLimiter מתודה שאיש לא צריך מלבדה.

מה הבדיקה עושההתוצאה
getDeclaredField("remaining"), אחר כך setAccessible(true), ואז get(limiter)מתקבל 97 והבדיקה עוברת
אותו דבר בלי setAccessibleget זורקת IllegalAccessException
getField("remaining") במקום getDeclaredFieldNoSuchFieldException, כי השדה לא ציבורי
מחלקת בדיקה שיורשת מ-RateLimiter וניגשת לשדה ישירותשגיאת הידור: private חסום גם בפני יורשת

זה שימוש לגיטימי ונפוץ, והוא חוסך שינוי בקוד הנבדק. אבל הוא קושר את הבדיקה למימוש: אם מחר remaining יקבל שם אחר או יהפוך ל-long, הבדיקה תיפול אף שההתנהגות של המחלקה לא השתנתה.

בקוד שרץ בייצור החשבון שונה. דמיינו מחלקה Wallet שהמתודה withdraw שלה מסרבת לרדת מתחת לאפס, ושדה private long balance:

  • מתי מגלים טעות: כתיבה ישירה ל-balance הייתה נעצרת בהידור. דרך Field, שגיאת כתיב בשם השדה או טיפוס לא נכון מתגלים רק כשהשורה רצה.
  • כימוס: קוד זר שכותב ל-balance דרך Field פתוח מדלג על הבדיקה של withdraw, ומשאיר את הארנק במצב שהמחלקה הבטיחה שלא יקרה.
  • אבטחה: באותה דרך אפשר לקרוא שדה פרטי שמחזיק סיסמה או מפתח, או להפעיל בנאי private, למשל של Singleton, ולקבל ממנו אובייקט נוסף.
  • ביצועים: כל גישה כזו איטית מגישה רגילה, כפי שנמדוד בחלק על המחיר.

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

טעויות נפוצות
  • בלי שום הכנה, רפלקציה קוראת שדות פרטיים כמו ציבוריים. ברירת המחדל מכבדת את ההרשאות. בלי setAccessible(true) הקריאה נגמרת ב-IllegalAccessException.
  • קריאה אחת ל-setAccessible(true) פותחת את כל החברים הפרטיים בתוכנית. היא משפיעה רק על אובייקט ה-Field או ה-Method שעליו הופעלה. כל אובייקט אחר צריך פתיחה משלו.
  • אחרי setAccessible אפשר לקרוא את השדה, אבל ה-JVM עדיין חוסמת כתיבה. גם field.set עובדת, כפי שראיתם כשהערך התחלף בפלט.
  • setAccessible משנה את מגדיר הגישה של השדה ל-public בקובץ המקור. שום קובץ לא משתנה, לא ה-java ולא ה-class. השדה נשאר private, ורק בדיקת הגישה של אובייקט ה-Field כבויה.
  • גישה ל-private דרך רפלקציה נכשלת כבר בקומפילציה. המהדר רואה רק קריאות למתודות של Field, והן חוקיות לגמרי. הבדיקה נעשית בזמן ריצה, ושם נזרקת החריגה אם השדה לא נפתח.
  • רפלקציה מסוכנת כי צריך להריץ את ה-JVM כמנהל מערכת. לא צריך שום הרשאה מיוחדת של מערכת ההפעלה. הסכנה היא עקיפת ההרשאות של המחלקה: כימוס, אבטחה, וגם ביצועים.
  • בתוכנית עם כמה שרשורים, קריאות רפלקציה נחסמות ועלולות להיכשל. ריבוי שרשורים לא משפיע על היכולת להשתמש ברפלקציה. זה פשוט לא אחד הסיכונים שלה.
בדקו את עצמכם
בקוד נקראה setAccessible(true) על ה-Field של private String token במחלקה Session. עכשיו הקוד משיג Field של private long expiresAt באותה מחלקה וקורא ל-get מיד. מה יקרה?

תיזרק IllegalAccessException. הפתיחה חלה רק על אובייקט ה-Field של token, ובאובייקט של expiresAt בדיקת הגישה עדיין פעילה.

אחרי setAccessible(true) ו-set על שדה פרטי, מישהו פותח את קובץ ה-java. מה כתוב בהצהרה של השדה?

עדיין private. רפלקציה לא נוגעת בקוד המקור או בקובץ ה-class; היא רק כיבתה בזמן הריצה את הבדיקה של אובייקט Field אחד.

חזרה לתוכן העניינים

אנוטציות ומי שקורא אותן: JUnit, הזרקת תלות ותוספים

אנוטציה (Annotation) היא סימון שמדביקים לפני מחלקה, מתודה, שדה או פרמטר, כמו @Override או @Test. לבדה היא לא מריצה דבר ולא משנה את הקוד: זו מטא-דאטה, ויש לה משמעות רק כשכלי או מסגרת קוראים אותה.

ב-C# אותו רעיון נקרא attribute, והוא נכתב בסוגריים מרובעים, למשל [Test].

האם קוד רפלקציה יראה אנוטציה מסוימת? זה נקבע בהגדרה של האנוטציה, בעזרת @Retention, שמקבל אחד משלושה ערכים:

RetentionPolicyמה קורה לאנוטציהרפלקציה בזמן ריצה רואה אותה?
SOURCEקיימת רק בקובץ ה-java; המהדר לא כותב אותה לקובץ ה-classלא
CLASS (ברירת המחדל)נכתבת לקובץ ה-class, אבל ה-JVM לא חושפת אותה לקודלא
RUNTIMEנכתבת לקובץ ה-class ונטענת יחד עם המחלקהכן

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

בדוגמה שלוש אנוטציות, אחת לכל ערך retention, והקוד מפעיל רק מתודות שמסומנות ב-@Step:

Java
import java.lang.annotation.*;
import java.lang.reflect.Method;
import java.util.Arrays;

@Retention(RetentionPolicy.RUNTIME) @interface Step { }
@interface Draft { }                                  // no @Retention: CLASS by default
@Retention(RetentionPolicy.SOURCE) @interface Memo { }

class Pipeline {
    @Step  public void fetch()   { System.out.println("    > fetch"); }
    @Draft public void enrich()  { System.out.println("    > enrich"); }
    @Memo  public void archive() { System.out.println("    > archive"); }
    @Step  public void publish() { System.out.println("    > publish"); }
}

public class App {
    public static void main(String[] cli) throws Exception {
        Object job = Pipeline.class.getDeclaredConstructor().newInstance();
        Method[] all = Pipeline.class.getDeclaredMethods();
        Arrays.sort(all, (x, y) -> x.getName().compareTo(y.getName()));   // stable order
        for (Method m : all) {
            System.out.println(m.getName() + ": annotations seen at run time = "
                               + m.getAnnotations().length);
            if (m.isAnnotationPresent(Step.class)) m.invoke(job);
        }
    }
}
פלט
archive: annotations seen at run time = 0
enrich: annotations seen at run time = 0
fetch: annotations seen at run time = 1
    > fetch
publish: annotations seen at run time = 1
    > publish

רק fetch ו-publish רצו. ל-enrich ול-archive יש סימון בקוד המקור, אבל getAnnotations() לא מצאה עליהן כלום: ל-@Draft לא הוגדר retention ולכן היא CLASS, ו-@Memo היא SOURCE.

את ההבדל בין שתיהן רואים בקובץ ה-class עצמו. הכלי javap מראה ש-@Draft נכתבה לקובץ (תחת RuntimeInvisibleAnnotations), ושל-@Memo אין שם זכר:

Bash
javap -v Pipeline.class | grep -E "L(Step|Draft|Memo);"
פלט
  #16 = Utf8               LStep;
  #19 = Utf8               LDraft;

החליפו בדוגמה את @Step ב-@Test ואת Pipeline במחלקת בדיקות, וקיבלתם את הליבה של JUnit. גם הוא מקבל מחלקה, מבקש ממנה את המתודות שלה, ומריץ את אלה שנושאות את @Test, אנוטציה שהוגדרה עם retention של RUNTIME בדיוק כדי שהוא יוכל לראות אותה.

הזרקת תלות (Dependency Injection) הופכת את כיוון האחריות: מחלקה שצריכה שירות לא בונה אותו בעצמה, אלא רק מבקשת אותו, למשל כפרמטר של הבנאי. מישהו אחר, ה-container, בונה את השירות ומעביר אותו. במסגרות אמיתיות כמו Spring ה-container גדול מאוד, אבל הליבה שלו נכנסת בכמה שורות:

Java
import java.lang.annotation.*;
import java.lang.reflect.Constructor;

@Retention(RetentionPolicy.RUNTIME) @Target(ElementType.CONSTRUCTOR) @interface Inject { }

interface PaymentPort { void charge(int cents); }

class Mailer {
    Mailer() { System.out.println("built Mailer"); }
    void send(String to) { System.out.println("mail sent to " + to); }
}

class SignupService {
    private final Mailer mailer;
    @Inject SignupService(Mailer mailer) {          // asks for a Mailer, never creates one
        System.out.println("built SignupService");
        this.mailer = mailer;
    }
    void register(String user) { mailer.send(user); }
}

class Billing {
    @Inject Billing(PaymentPort port) { }           // nobody provides a PaymentPort class
}

class TinyContainer {
    // build a class: use its @Inject constructor, building each parameter first
    static Object build(Class<?> type) throws Exception {
        for (Constructor<?> c : type.getDeclaredConstructors()) {
            if (c.isAnnotationPresent(Inject.class)) {
                Class<?>[] needs = c.getParameterTypes();
                Object[] parts = new Object[needs.length];
                for (int i = 0; i < needs.length; i++) parts[i] = build(needs[i]);
                return c.newInstance(parts);
            }
        }
        return type.getDeclaredConstructor().newInstance();   // no @Inject: no-arg constructor
    }
}

public class App {
    public static void main(String[] cli) throws Exception {
        SignupService s = (SignupService) TinyContainer.build(SignupService.class);
        s.register("user41");
        try {
            TinyContainer.build(Billing.class);
        } catch (NoSuchMethodException e) {
            System.out.println("missing dependency, found only now: " + e.getMessage());
        }
    }
}
פלט
built Mailer
built SignupService
mail sent to user41
missing dependency, found only now: PaymentPort.<init>()

עקבו אחרי build(SignupService.class): הפונקציה עברה על הבנאים, מצאה את זה שמסומן ב-@Inject ושאלה אותו אילו סוגי פרמטרים הוא מקבל.

כך היא גילתה שהוא צריך Mailer, בנתה קודם Mailer (השורה הראשונה בפלט), ורק אז הפעילה את הבנאי של SignupService עם newInstance. בשום מקום ב-TinyContainer לא כתוב new SignupService.

השורה האחרונה בפלט היא המחיר. Billing מבקשת PaymentPort, ואף מחלקה לא מממשת את הממשק הזה. הפרויקט התקמפל בלי בעיה, והחוסר התגלה רק כשה-container ניסה לבנות את התלות בזמן ריצה.

אפשר כמובן לוותר על כל זה ולכתוב ביד new SignupService(new Mailer()), או Factory שמרכז קריאות כאלה. זה עובד ונבדק בהידור, אבל אין כאן גילוי אוטומטי: כל רכיב חדש מחייב לעדכן את ה-Factory.

תרחיש 5: מסנן שהעורך לא הכיר

עורך תמונות נבנה ושוחרר לפני שנה. היום מישהו כותב jar עם מחלקה SepiaFilter ובה מתודה שמסומנת @Filter, ומוסיף את השם SepiaFilter לרשימת התוספים של העורך.

  1. בעלייה העורך קורא את הרשימה וטוען את SepiaFilter לפי השם, עם Class.forName.
  2. הוא עובר על המתודות שלה ומחפש את הסימון @Filter.
  3. את המתודה שמצא הוא מוסיף לתפריט, וכשהמשתמש בוחר בה הוא מפעיל אותה עם invoke.

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

Annotation Processing: לעשות את עבודת ה-container כבר בהידור. את מה ש-TinyContainer עשה בכל הרצה אפשר לעשות פעם אחת, כשהקוד מתקמפל. מעבד אנוטציות (annotation processor) הוא קוד ש-javac מפעיל באמצע ההידור, והוא מקבל גישה לאנוטציות שבקוד המקור.

מעבד כזה היה רואה את @Inject על הבנאי של SignupService וכותב קובץ מקור חדש, נניח SignupServiceFactory.java, ובו שורה אחת: return new SignupService(new Mailer());. הקובץ הזה מתקמפל יחד עם שאר הפרויקט כמו כל קובץ אחר.

התוצאה: בזמן ריצה לא צריך לחפש בנאים, ולכן אין עלות של רפלקציה. ובמקרה של Billing, הקוד שנכתב היה צריך לבנות PaymentPort, והמהדר היה עוצר את הבנייה כבר עכשיו, במקום שה-container ייכשל אחר כך.

תרחיש 6: פקודות שאף אחד לא מריץ

בכלי שורת פקודה, כל מתודה שמסומנת ב-@Command אמורה להפוך לפקודה. המפתחת הגדירה את האנוטציה כ-@interface Command { } ולא הוסיפה @Retention.

  1. בלי @Retention הערך הוא CLASS: האנוטציה נכתבת לקובץ ה-class, אבל לא זמינה בזמן ריצה.
  2. הכלי עובר על המתודות ושואל isAnnotationPresent(Command.class), והתשובה היא false לכל אחת.
  3. הכלי עולה כרגיל, אבל אין לו אף פקודה.

התיקון הוא שורה אחת בהגדרה: @Retention(RetentionPolicy.RUNTIME). הוספה של @Documented או @Inherited לא הייתה משנה דבר.

טעויות נפוצות
  • retention מסוג CLASS מספיק, כי האנוטציה כבר נמצאת בקובץ ה-class. היא אכן בקובץ, אבל ה-JVM לא חושפת אותה לרפלקציה. רק RUNTIME נראית בזמן ריצה.
  • JUnit מוצא בדיקות לפי המילה test בטקסט של קובצי ה-java. הוא בכלל לא פותח קוד מקור. הוא סורק את המתודות ברפלקציה ובודק אם הן מסומנות באנוטציה.
  • JUnit מריץ כל מתודה ציבורית שיש במחלקת הבדיקות, או מקבל מהמהדר רשימה מוכנה של בדיקות. אין לו רשימה מהמהדר, והוא גם לא מריץ הכול: הוא בוחר בעצמו, בזמן ריצה, רק את המתודות שמסומנות ב-@Test.
  • מסגרת הזרקה מבוססת רפלקציה מוודאת בהידור שכל התלויות זמינות. הסריקה שלה רצה רק כשהתוכנית רצה. ראיתם את זה עם Billing: הפרויקט התקמפל, והחוסר התגלה בהרצה.
  • הזרקת תלות פועלת בניתוח סטטי של המקור, שבסופו נוצר קובץ XML. בצורה הנפוצה המסגרת סורקת מחלקות ואנוטציות בזמן ריצה, בונה את האובייקטים ומזריקה אותם.
  • ה-container מסנכרן בין שרשורים את הגישה לאובייקטים שהוא בנה, ושומר על הכימוס בכך שהוא חוסם שדות פרטיים. רפלקציה במסגרת כזו משמשת רק לגילוי ולבנייה. סנכרון בין שרשורים הוא עניין נפרד לגמרי, ושדות פרטיים היא לא חוסמת.
  • מעבד אנוטציות מריץ את התוכנית בזמן ההידור ושומר את מה שהרפלקציה גילתה. הוא לא מריץ דבר מהתוכנית. הוא קורא את האנוטציות במקור ומייצר מהן קוד נוסף.
  • מעבד אנוטציות טוען מראש את המחלקות ל-JVM, או מסיר את האנוטציות מקובצי ה-class כדי לחסוך חיפוש. הוא עובד על קוד מקור בתוך המהדר, לא על ה-JVM שתריץ את התוכנית. מה שנשאר בקובצי ה-class נקבע רק לפי ה-retention.
בדקו את עצמכם
בשתי מסגרות הזרקה חסרה תלות. אחת סורקת ברפלקציה בזמן ריצה, והשנייה מייצרת קוד עם annotation processor. איזו מהן תגלה את החוסר לפני שהתוכנית עולה, ולמה?

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

אנוטציה @Hint מוגדרת עם @Retention(RetentionPolicy.SOURCE). מנוע שסורק מתודות בזמן ריצה מחפש אותה. מה ימצא?

כלום. אנוטציה מסוג SOURCE לא נכתבת אפילו לקובץ ה-class, ולכן בזמן ריצה אין לה שום זכר.

חזרה לתוכן העניינים

Proxy דינמי, AOP ושינוי bytecode

Proxy (מתווך) הוא אובייקט שתופס את מקומו של אובייקט אחר. מי שמחזיק בו קורא למתודות כרגיל, וה-Proxy מחליט מה לעשות בכל קריאה: להעביר אותה הלאה, לשנות אותה, או לענות בעצמו.

ב-Java אין צורך לכתוב מחלקת Proxy ביד: java.lang.reflect.Proxy מייצר אותה בזמן ריצה. הדוגמה עוטפת כך את הממשק PriceList, ואחריה נפרק מה קרה:

Java
import java.lang.reflect.*;
import java.util.Arrays;

interface PriceList { int priceOf(String item); }

class ShopPrices implements PriceList {
    public int priceOf(String item) { return item.length() * 4; }
}

public class App {
    public static void main(String[] cli) {
        PriceList target = new ShopPrices();
        InvocationHandler audit = (self, m, callArgs) -> {
            System.out.println("[audit] enter " + m.getName() + Arrays.toString(callArgs));
            Object answer = m.invoke(target, callArgs);    // forward to the real object
            System.out.println("[audit] leave " + m.getName() + " = " + answer);
            return answer;
        };
        PriceList wrapped = (PriceList) Proxy.newProxyInstance(
            PriceList.class.getClassLoader(), new Class<?>[] { PriceList.class }, audit);

        int p = wrapped.priceOf("melon");
        System.out.println("caller got " + p);
        System.out.println("is a PriceList:  " + (wrapped instanceof PriceList));
        System.out.println("is a ShopPrices: " + (wrapped instanceof ShopPrices));
        System.out.println("generated class: " + Proxy.isProxyClass(wrapped.getClass()));
    }
}
פלט
[audit] enter priceOf[melon]
[audit] leave priceOf = 20
caller got 20
is a PriceList:  true
is a ShopPrices: false
generated class: true
  1. Proxy.newProxyInstance קיבלה class loader, מערך עם הממשק PriceList, ואת audit, שהוא InvocationHandler. היא ייצרה בזיכרון מחלקה חדשה שמממשת את PriceList והחזירה מופע שלה; השורה האחרונה בפלט מאשרת שזו מחלקה שנוצרה כך.
  2. הקריאה wrapped.priceOf("melon") לא הגיעה ל-ShopPrices. היא הגיעה ל-lambda של המטפל, יחד עם m, אובייקט ה-Method של priceOf, ועם callArgs, מערך שמכיל את melon.
  3. המטפל הדפיס enter, העביר את הקריאה בעצמו ל-target עם m.invoke, הדפיס leave והחזיר את 20, וזה מה שקיבל הקורא.
  4. wrapped עובר instanceof PriceList אבל לא instanceof ShopPrices: הוא אובייקט אחר, שרק מחזיק הפניה לאמיתי. ShopPrices לא השתנתה בכלל.

AOP בזמן ריצה. החליפו את שתי שורות ה-audit בפתיחה וסגירה של טרנזקציה, או בבדיקה שלמשתמש יש הרשאה לפעולה, וקיבלתם את הרעיון של תכנות מונחה היבטים (AOP, Aspect-Oriented Programming). זו התנהגות שחוצה את כל המערכת ומתווספת למתודות קיימות מבחוץ.

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

ממשק שאף מחלקה לא הכריזה עליו. לפעמים יש מחלקה ישנה שיש לה בדיוק את המתודה הנכונה, אבל היא לא כתבה implements. ב-Java זה לא מספיק: השפה לא עובדת ב-duck typing, ודמיון בשמות לא הופך מחלקה למממשת של ממשק. Proxy יכול לגשר על הפער:

Java
import java.lang.reflect.*;

interface PriceList { int priceOf(String item); }

class LegacyPrices {                        // same method, but no "implements PriceList"
    public int priceOf(String item) { return item.length() * 11; }
}

public class App {
    public static void main(String[] cli) {
        Object legacy = new LegacyPrices();
        try {
            PriceList.class.cast(legacy);
        } catch (ClassCastException e) {
            System.out.println("cast: " + e.getMessage());
        }

        // forward each call to the method with the same name and parameter types
        InvocationHandler bridge = (self, m, a) ->
            legacy.getClass().getMethod(m.getName(), m.getParameterTypes()).invoke(legacy, a);
        PriceList adapted = (PriceList) Proxy.newProxyInstance(
            PriceList.class.getClassLoader(), new Class<?>[] { PriceList.class }, bridge);

        System.out.println("via proxy: " + adapted.priceOf("pear"));
        System.out.println("LegacyPrices interfaces: " + LegacyPrices.class.getInterfaces().length);
    }
}
פלט
cast: Cannot cast LegacyPrices to PriceList
via proxy: 44
LegacyPrices interfaces: 0

Class.cast נכשל, כי הוא רק בודק אם האובייקט כבר מהטיפוס המבוקש וממיר את ההפניה; להוסיף מימוש הוא לא יודע. המטפל bridge, לעומת זאת, משתמש במטא-דאטה של כל קריאה (שם המתודה וסוגי הפרמטרים), מאתר ב-LegacyPrices מתודה תואמת ומפעיל אותה.

השורה השלישית מזכירה ש-LegacyPrices עצמה לא קיבלה שום ממשק. אובייקט ה-Class רק מתאר את המחלקה כפי שהוגדרה, ואין בו רשימת ממשקים שאפשר לערוך; מה שמממש את PriceList הוא ה-Proxy.

מגבלה חשובה: java.lang.reflect.Proxy עובד רק עם ממשקים. הדוגמה הבאה מראה מה מקבל הקורא כשהמטפל לא מעביר את הקריאה הלאה, ומה קורה כשמנסים לתת למנגנון מחלקה:

Java
import java.lang.reflect.*;

interface Catalog {
    String label(int id);
    int stock(int id);
}

class FileCatalog implements Catalog {
    public String label(int id) { return "item-" + id; }
    public int stock(int id) { return 5; }
}

public class App {
    public static void main(String[] cli) {
        // a handler that never forwards the call to a real object
        InvocationHandler silent = (self, m, a) -> {
            System.out.println("called " + m.getName());
            return null;
        };
        Catalog c = (Catalog) Proxy.newProxyInstance(
            Catalog.class.getClassLoader(), new Class<?>[] { Catalog.class }, silent);

        System.out.println("label -> " + c.label(8));
        try {
            int n = c.stock(8);                     // null cannot become an int
            System.out.println("stock -> " + n);
        } catch (NullPointerException e) {
            System.out.println("stock -> NullPointerException");
        }

        try {
            Proxy.newProxyInstance(App.class.getClassLoader(),
                new Class<?>[] { FileCatalog.class }, silent);   // a class, not an interface
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }
    }
}
פלט
called label
label -> null
called stock
stock -> NullPointerException
FileCatalog is not an interface

המטפל החזיר null בלי לפנות לשום אובייקט אמיתי, ולכן label החזירה null. ב-stock אותו null היה צריך להפוך ל-int, ונזרקה NullPointerException; וכשהועברה מחלקה במקום ממשק, יצירת ה-Proxy נכשלה מיד.

Bytecode Manipulation: נכנסים לתוך המחלקה. יש גם דרך הפוכה לגמרי. במקום לבנות עטיפה מבחוץ, ספרייה כמו ASM פותחת את ה-bytecode של ShopPrices, כלומר את ההוראות שבקובץ ה-class, ומוסיפה לתוכו את שורות ה-audit. זה קורה לפני שהמחלקה רצה: בשלב הבנייה, או בזמן שה-Class Loader טוען אותה.

היבטProxy דינמיBytecode Manipulation (למשל ASM)
מה נוצר או משתנהאובייקט חדש בזמן ריצה שעוטף ממשקההוראות של המחלקה עצמה
המחלקה המקוריתנשארת כפי שהייתהרצה עם הוראות שונות
קובץ ה-class שבדיסקלא נכתב מחדשתלוי בכלי; מה שמשתנה הוא ה-bytecode, לא קוד המקור
מחלקה שאין לה ממשקלא נתמכתנתמכת
צריך קוד מקור?לאלא, עובדים ישירות על ה-bytecode
צריך הרשאות של מערכת ההפעלה?לאלא
תרחיש 7: מדידת זמן לכל קריאה, בלי לפתוח את הקוד

הצוות רוצה לדעת כמה זמן לוקחת כל קריאה למתודות של הממשק PaymentGateway, בלי לשנות שורה במחלקה המממשת CardGateway.

בונים Proxy דינמי ל-PaymentGateway עם מטפל ששומר את System.nanoTime(), מעביר את הקריאה למימוש האמיתי עם method.invoke ומדפיס כמה זמן עבר. בכל מקום שקיבל עד עכשיו PaymentGateway, מעבירים מעכשיו את ה-Proxy.

CardGateway לא השתנתה ולא יודעת שמישהו עוטף אותה. אילו רצו למדוד גם מחלקה שלא מממשת אף ממשק, java.lang.reflect.Proxy לא היה מספיק, והיה צורך בכלי שמייצר מחלקת-בת או משנה bytecode.

טעויות נפוצות
  • AOP בזמן ריצה כותב מחדש את קוד המקור של המתודות ושומר אותו. הוא לא נוגע במקור. הוא עוטף את האובייקט ב-Proxy ומפעיל את המתודות המקוריות ברפלקציה.
  • כדי שהקוד הנוסף ירוץ, AOP בונה מחדש את קובצי המחלקות לפני כל הפעלה של מתודה, או מחייב כל מחלקה לממש את הלוגיקה בעצמה. ה-Proxy נבנה פעם אחת בזמן ריצה, והקוד הנוסף נמצא במטפל. המחלקות העטופות לא יודעות עליו דבר.
  • Proxy דינמי מחליף את התוכן של קובץ ה-class שבדיסק. הוא יוצר מחלקה ואובייקט חדשים בזיכרון, בזמן ריצה. הקבצים בדיסק לא משתנים.
  • כדי לשנות bytecode צריך את קוד המקור של המחלקה. עובדים ישירות על ה-bytecode שבקובץ ה-class; המקור לא נחוץ.
  • אפשר להוסיף ממשק למחלקה קיימת אם עורכים את רשימת הממשקים באובייקט ה-Class שלה. אובייקט ה-Class רק מתאר את ההגדרה, ואין בו שדה כזה לעריכה. מימוש של ממשק חדש מקבלים מ-Proxy או משינוי bytecode.
בדקו את עצמכם
Proxy דינמי עוטף ממשק Inventory. המטפל מדפיס את שם המתודה ומחזיר null, בלי method.invoke. מה יקבל מי שקורא ל-inventory.findByCode("X1"), שמחזירה String?

null, אחרי שהודפס findByCode. האובייקט האמיתי לא הופעל, כי המטפל לא העביר אליו את הקריאה. אילו המתודה הייתה מחזירה int, ה-null לא היה יכול להפוך למספר והייתה נזרקת NullPointerException.

רוצים לעטוף עם java.lang.reflect.Proxy את המחלקה ReportBuilder, שלא מממשת אף ממשק. זה יעבוד?

לא. המנגנון מקבל רק ממשקים, ומחלקה נדחית ב-IllegalArgumentException. במקרה כזה צריך כלי שמייצר מחלקת-בת או משנה את ה-bytecode.

חזרה לתוכן העניינים

המחיר: ביצועים, בדיקת טיפוסים ושבירות

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

Java
import java.lang.reflect.Method;

class Tax {
    public int vat(int amount) { return amount * 17 / 100; }
}

public class App {
    // looked up once, when App is initialized, then reused
    private static final Method VAT;
    static {
        try {
            VAT = Tax.class.getMethod("vat", int.class);
        } catch (NoSuchMethodException e) {
            throw new ExceptionInInitializerError(e);
        }
    }

    public static void main(String[] cli) throws Exception {
        Tax tax = new Tax();
        long a = 0, b = 0, c = 0;
        for (int i = 0; i < 500_000; i++) {
            // worst: name lookups on every pass
            Method m = Class.forName("Tax").getMethod("vat", int.class);
            a += (Integer) m.invoke(tax, i % 100);    // int boxed in, Integer unboxed out
        }
        for (int i = 0; i < 500_000; i++) {
            b += (Integer) VAT.invoke(tax, i % 100);  // cached Method: no lookups
        }
        for (int i = 0; i < 500_000; i++) {
            c += tax.vat(i % 100);                    // plain call, checked at compile time
        }
        System.out.println(a + " " + b + " " + c);
    }
}
פלט
3960000 3960000 3960000

שלושת הסכומים זהים, אבל כמות העבודה בכל סיבוב שונה מאוד:

לולאהמה קורה בכל סיבוב
הראשונהחיפוש המחלקה לפי מחרוזת ב-forName, חיפוש המתודה לפי שם וסוגי פרמטרים ב-getMethod, ואז invoke, שבודקת הרשאה ומתאימה את הארגומנטים, אורזת את ה-int ל-Integer בתוך מערך Object ומחזירה Object
השנייהרק invoke עם הבדיקות והאריזה; החיפוש נעשה פעם אחת, באתחול של VAT
השלישיתקריאה רגילה, שנקשרה ליעד שלה פעם אחת ושהמהדר כבר אימת

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

בקריאה בודדת ההפרש זניח; בחצי מיליון סיבובים הוא מורגש מאוד, והוא כולו בזמן הריצה. ושימו לב מה לא קורה בלולאה הראשונה, למרות חצי מיליון קריאות ל-forName: Tax.class לא נקרא מהדיסק שוב. המחלקה נטענה בפעם הראשונה ונשארה בזיכרון, ומה שחוזר על עצמו הוא החיפוש.

הלולאה השנייה היא התיקון המקובל: השדה static final Method VAT מחזיק את מה שנמצא פעם אחת, וכל סיבוב משתמש בו שוב. אובייקט Method לא מתיישן כל עוד המחלקה לא הוחלפה, כך שאין שום סיבה לחפש אותו בכל קריאה; כשיש הרבה מתודות כאלה, מחזיקים אותן במפה.

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

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

בדיקת טיפוסים שהולכת לאיבוד. דמיינו שבלולאה הראשונה היה כתוב Class.forName("Taks"). הקובץ היה מתקמפל בלי הערה, וה-ClassNotFoundException הייתה מופיעה רק בסיבוב הראשון של ההרצה. כך גם getMethod("vatt", int.class): מתקמפלת, ונגמרת ב-NoSuchMethodException רק בהרצה.

עם cast שגוי של התוצאה המצב עדין יותר. בתוך הלולאה, a += (String) m.invoke(...) לא היה עובר הידור, כי המהדר יודע ש-a הוא long ושאי אפשר להוסיף לו String. אבל כשהתוצאה נשמרת במשתנה מהטיפוס שה-cast מבטיח, המהדר רואה רק Object שהופך ל-String ומאשר:

Java
import java.lang.reflect.Method;
class Tax { public int vat(int amount) { return amount * 17 / 100; } }
public class App {
    public static void main(String[] cli) throws Exception {
        Method m = Tax.class.getMethod("vat", int.class);
        String label = (String) m.invoke(new Tax(), 5);
    }
}
פלט
Exception in thread "main" java.lang.ClassCastException: java.lang.Integer cannot be cast to java.lang.String
	at App.main(App.java:6)

invoke מצהירה שהיא מחזירה Object, ולכן מבחינת המהדר כל cast ממנה לטיפוס הפניה הוא אפשרי. רק בהרצה מתברר שבפנים יושב Integer, ואז נזרקת ClassCastException.

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

מה שכן נשאר: ה-cast (Integer) בלולאות נבדק בזמן ריצה, ואם הוא עובר, מכאן והלאה יש בידכם טיפוס רגיל ומוכר. וגם כש-Tax נטענת דרך forName, ה-JVM מריצה עליה את מאמת ה-bytecode כמו על כל מחלקת אפליקציה שהיא טוענת.

גם כלי ניתוח סטטי, שקורא את הקוד כטקסט ובונה ממנו תמונה של מי קורא למי בלי להריץ דבר, נתקע באותה נקודה. כשהוא מגיע ל-getMethod(handlerName) ול-invoke שאחריה, הוא מסמן אותן ויודע שכאן תופעל מתודה כלשהי ברפלקציה.

איזו מתודה, הוא לא יכול לומר. התשובה תלויה בתוכן של handlerName, שמגיע מ-args או מקובץ הגדרות ונוצר רק כשהתוכנית כבר רצה, ולכן בתמונה שלו נשאר שם סימן שאלה.

תרחיש 8: שגיאת כתיב שהמהדר לא יכול היה לראות

שירות הזמנות קורא מקובץ הגדרות את שם המתודה שמטפלת בהחזרים, refundPaymnt (חסרה e), ומפעיל אותה ברפלקציה.

שלבמה קורה
הידורעובר, כי מבחינת המהדר זו מחרוזת
ניתוח סטטיהכלי מסמן קריאה רפלקטיבית, אבל לא יודע לאיזו מתודה
הרצה, בהחזר הראשוןgetMethod זורקת NoSuchMethodException

אילו הקוד היה כותב service.refundPaymnt() ישירות, המהדר היה עוצר את הבנייה מיד.

שבירות מול obfuscation. כאן הבעיה לא נובעת משגיאה שלכם, אלא מכלי שמשנה שמות אחרי שכתבתם אותם:

תרחיש 9: אותו אובייקט, שני JSON שונים

אפליקציה שולחת לשרת אובייקט Ticket עם השדות seat ו-row, בעזרת ספריית JSON שמגלה את השדות ברפלקציה.

  • בגרסת הפיתוח נשלח {"seat":"12C","row":7}.
  • בגרסה שעברה obfuscator השדות נקראים a ו-b, ונשלח {"a":"12C","b":7}.
  • בכיוון ההפוך, כשהספרייה מחפשת שדה בשם seat כדי למלא אותו מתשובת השרת, היא לא מוצאת אותו ונכשלת.

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

obfuscator כמו ProGuard מחליף בקובצי ה-class שמות של מחלקות, שדות ומתודות באותיות חסרות משמעות, כדי שיהיה קשה לפרק את האפליקציה ולהבין אותה. הוא משכתב גם כל מקום שמשתמש בשם, ולכן ticket.seat בקוד שלכם הופך ל-ticket.a ועובד. המחרוזת seat בתוך הספרייה היא לא הפניה, ואותה הוא לא נוגע.

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

החלפת גרסה בזמן ריצה (hot swapping). התוכנית הבאה טוענת את Widget.class פעמיים, כל פעם דרך URLClassLoader אחר, כמו מערכת שמחליפה גרסה של תוסף בלי לאתחל את עצמה. Widget היא מחלקה קטנה עם מתודה ציבורית version():

Java
import java.io.File;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;

public class App {
    public static void main(String[] cli) throws Exception {
        URL[] where = { new File("../plug").toURI().toURL() };
        ClassLoader oldLoader = new URLClassLoader(where, null);
        ClassLoader newLoader = new URLClassLoader(where, null);   // the "reload"

        Class<?> oldWidget = oldLoader.loadClass("Widget");
        Method cachedVersion = oldWidget.getMethod("version");      // kept from before
        Class<?> newWidget = newLoader.loadClass("Widget");

        System.out.println(oldWidget.getName() + " vs " + newWidget.getName());
        System.out.println("same class object: " + (oldWidget == newWidget));

        Object fresh = newWidget.getDeclaredConstructor().newInstance();
        try {
            cachedVersion.invoke(fresh);           // old Method, new-version object
        } catch (IllegalArgumentException e) {
            System.out.println("cached Method refused the new object: " + e.getMessage());
        }
        try {
            oldWidget.cast(fresh);
        } catch (ClassCastException e) {
            System.out.println("ClassCastException: " + e.getMessage());
        }
    }
}
פלט
Widget vs Widget
same class object: false
cached Method refused the new object: object is not an instance of declaring class
ClassCastException: Cannot cast Widget to Widget

מבחינת ה-JVM אלה שתי מחלקות זרות, אף שהשם זהה: מחלקה מזוהה גם לפי ה-Class Loader שטען אותה. ה-Method שנשמר מהטעינה הראשונה דוחה אובייקט של הטעינה השנייה, וה-cast נכשל בהודעה המבלבלת Cannot cast Widget to Widget.

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

מאותה סיבה Singleton מבטיח מופע אחד לכל Class Loader, ולא מופע אחד לכל התהליך.
המחירמתי מרגישים אותו
מהירותבקטעים חמים, כמו לולאה שקוראת ל-invoke שוב ושוב
בדיקות המהדרבפעם הראשונה שהשורה עם השם השגוי רצה
כימוסכשמישהו כתב לשדה פרטי ועקף את הבדיקות של המחלקה
שינוי שמותבגרסה שעברה obfuscation
הידור מראש (AOT)ב-GraalVM native-image או ב-Native AOT של .NET, שבהם צריך להגדיר לבנייה מראש למה ייגשו ברפלקציה
טעויות נפוצות
  • בזכות ה-JIT, קריאה ברפלקציה עולה בדיוק כמו קריאה ישירה. בכל קריאה יש חיפוש, בדיקות ואריזה, ויעד שנקבע רק בזמן ריצה קשה יותר להטמיע.
  • כדאי לשלוף את ה-Method שוב לפני כל קריאה, כדי שלא יתיישן. החיפוש החוזר הוא בדיוק מה שמאט. אובייקט Method נשאר תקף, ושומרים אותו במטמון.
  • רפלקציה מתבצעת בהידור, ולכן אין לה עלות בזמן ריצה. ההפך: כל העבודה שלה, וכל העלות שלה, הן בזמן ריצה.
  • מחלקה שנטענת ברפלקציה פטורה מאימות bytecode. ה-JVM מאמתת את מחלקות האפליקציה שהיא טוענת, לא משנה מי ביקש את הטעינה.
  • המהדר בודק שהמחרוזת שמועברת ל-Class.forName היא שם של מחלקה קיימת. מבחינתו זו מחרוזת כמו כל מחרוזת. שם שגוי יתגלה רק בהרצה.
  • Class Loader חדש מחליף את הגרסה הישנה של המחלקה בכל התוכנית. הגרסה הישנה נשארת, וכל מה ששמר הפניות אליה ממשיך לעבוד מולה.
  • פרויקט שמשתמש הרבה ברפלקציה נבנה לאט יותר, ושרשורים שמשתמשים בה נכנסים ל-Race Condition. רפלקציה לא מוסיפה עבודה למהדר, וגם לא יוצרת מרוץ בין שרשורים. כל המחירים שלה מופיעים בטבלה למעלה, ואלה לא ביניהם.
בדקו את עצמכם
קוד מאתר מתודה ברפלקציה ומפעיל אותה פעם אחת כשהשרת עולה, ומשם והלאה קורא לה ישירות. האם שווה לבנות מטמון לאובייקט ה-Method?

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

שם מחלקה שגוי כתוב בקובץ הגדרות ומועבר ל-Class.forName. מתי תגלו את הטעות?

רק כשהשורה תרוץ ותיזרק ClassNotFoundException. המהדר רואה מחרוזת ולא יכול לבדוק אותה.

חזרה לתוכן העניינים

Garbage Collector: מי מפנה את הזיכרון

תפקיד ה-GC: שורשים, נגישות ומתי משחררים

נתחיל מהבעיה. ב-C אתם מקבלים זיכרון מ-malloc ומחזירים אותו ב-free, וב-C++ הזוג הוא new ו-delete. כל החזרה כזו היא החלטה של המתכנת, ובכל מקום שבו ההחלטה הזו מתקבלת אפשר לטעות.

יש שלוש טעויות קלאסיות שכדאי להכיר בשמן:

  • שחרור כפול (double free): אותו בלוק מוחזר למקצה פעמיים, ומבני הנתונים של המקצה עצמו נפגעים.
  • הפניה תלויה (dangling pointer): הבלוק כבר הוחזר, אבל נשאר מצביע שממשיך לקרוא ולכתוב דרכו.
  • דליפה (leak): אף אחד לא מחזיר את הבלוק, והוא תפוס עד שהתוכנית מסתיימת.

ב-Java וב-C# התפקיד הזה עובר לסביבת הריצה עצמה (ה-JVM או ה-CLR), לרכיב שנקרא אוסף האשפה (Garbage Collector, או GC). כל אובייקט שנוצר ב-new יושב בערמה (heap), אזור אחד שכל השרשורים של התהליך חולקים, וה-GC הוא שמחליט בזמן ריצה מה מתוכו אפשר לפנות.

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

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

כדאי גם לדעת מה ה-GC לא עושה. הוא לא מקצה: את המקום לאובייקט חדש מספק new בעזרת המקצה של סביבת הריצה; ה-GC אחראי רק על הצד השני, הפינוי. והוא לא קשור לסנכרון בין שרשורים: הוא לא נועל דבר ולא מונע Race Condition.

איך ה-GC יודע מה עוד בשימוש? הוא לא מנחש. הוא מתחיל מקבוצה של הפניות שבוודאות עדיין חיות, שנקראות שורשים (GC roots):

  • שדות static של כל מחלקה שנטענה.
  • משתנים מקומיים ופרמטרים שנמצאים במסגרות (frames) הפעילות במחסנית של כל שרשור.
  • השרשורים החיים עצמם.
  • הפניות שמחזיק קוד native, למשל דרך JNI.

מכל שורש ה-GC הולך בעקבות ההפניות, שדה אחרי שדה. אובייקט שאפשר להגיע אליו בשרשרת כזו הוא נגיש (reachable) ונשאר; אובייקט שאף שרשרת לא מגיעה אליו הוא אשפה, ומותר לפנות אותו.

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

Java
import java.lang.ref.WeakReference;

class Route {
    String name;
    Route(String name) { this.name = name; }
}

class Trip {
    Route route;                       // Trip -> Route
}

public class Main {
    static boolean survives(WeakReference<?> w) throws InterruptedException {
        for (int i = 0; i < 5 && w.get() != null; i++) {
            System.gc();                   // a request, not an order
            Thread.sleep(40);
        }
        return w.get() != null;
    }

    public static void main(String[] argv) throws InterruptedException {
        Trip trip = new Trip();            // local variable: a root
        trip.route = new Route("Haifa-Eilat");
        WeakReference<Route> probe = new WeakReference<>(trip.route);

        System.out.println("chain root->trip->route: " + survives(probe));
        trip.route = null;                 // cut the middle link, trip itself stays
        System.out.println("link cut, before any GC: " + (probe.get() != null));
        System.out.println("link cut, after GC: " + survives(probe));
        System.out.println("trip still here: " + (trip != null));
    }
}
פלט
chain root->trip->route: true
link cut, before any GC: true
link cut, after GC: false
trip still here: true

WeakReference משמשת כאן רק כחיישן: היא מאפשרת לשאול אם האובייקט עוד קיים, בלי להחזיק אותו בחיים (נחזור אליה בהמשך). השורה השנייה בפלט היא העיקר: מיד אחרי ש-trip.route קיבל null האובייקט עוד בזיכרון.

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

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

ומה אם רוצים לזרז? כאן Java ו-.NET נבדלות. ב-.NET GC.Collect() באמת מפעילה איסוף, אף שההנחיה הרשמית היא לא להשתמש בה; ב-Java System.gc() רק מביעה משאלה, וה-JVM חופשית להתעלם ממנה.

ב-C וב-C++ב-Java וב-C#
איך נראה הקודלכל malloc או new מצפים לשורת free או delete תואמתאין שורת שחרור בכלל
על סמך מה אובייקט מתפנההמתכנת החליט שסיים איתואף שרשרת מהשורשים לא מגיעה אליו
רגע הפינויידוע מראש: השורה שבה נכתב השחרורלא ידוע: האיסוף שסביבת הריצה תבחר להריץ
מה מנוהלהבלוקים שהוקצו בערמההאובייקטים שבערמה
מה משתבששוכחים לשחרר, משחררים פעמיים, או ממשיכים לגשת אחרי שחרורהפניה שנשכחה מחזיקה אובייקט מיותר; התוכנית נעצרת לרגעים בזמן איסוף
תרחיש 10: משתמש שהתנתק, ואובייקט שעוד לא נעלם

שרת התחברות יוצר במתודה login אובייקט Session ושומר אותו גם במפה סטטית active לפי מזהה המשתמש.

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

כשהמשתמש מתנתק, הקוד מריץ active.remove(id). עכשיו אין שום שרשרת מהשורשים אל ה-Session, והוא זכאי. הזיכרון שלו יתפנה באיסוף כלשהו שיבוא אחר כך, לא בשורה של remove.

טעויות נפוצות
  • ה-GC עובד על המחסנית ומנקה ממנה משתנים. ה-GC מטפל בערמה. המחסנית רק תורמת לו חלק מהשורשים: המשתנים המקומיים והפרמטרים.
  • ה-GC הוא זה שנותן זיכרון לכל אובייקט חדש. את ההקצאה מבצע new דרך המקצה של סביבת הריצה. ה-GC רק מאתר מה אפשר לפנות ומפנה.
  • הפינוי מתבצע בדיוק בשורה שבה ההפניה האחרונה נעלמת. באותה שורה האובייקט רק נעשה זכאי. הפינוי מגיע מתי שסביבת הריצה תריץ איסוף.
  • תוכנית עם GC חסכונית יותר בזיכרון ומהירה יותר. ה-GC עולה זמן מעבד וזיכרון. מה שמרוויחים הוא היעדר קוד שחרור, ואיתו הרבה פחות באגים ודליפות.
  • את השחרורים מוסיף המהדר, כך שכל העבודה נעשית כבר בהידור. ה-GC הוא חלק מסביבת הריצה, ומחליט בזמן ריצה לפי מה שנגיש באותו רגע.
  • GC מצמצם דליפות כי בשפה אין גישה ישירה לכתובות. היעדר pointers הוא תכונה של השפה, לא של ה-GC. את הדליפות מצמצם איתור אוטומטי של אובייקטים לא נגישים ושחרורם.
בדקו את עצמכם
נכתב Order o1 = new Order(); Order o2 = o1; o1 = null;. אחרי השורה האחרונה, האם ה-Order זכאי לאיסוף?

לא. o2 עדיין מחזיק אותו, כך שיש שרשרת מהשורשים (המשתנה המקומי) אל האובייקט.

קוד בדיקה קורא ל-System.gc() ומיד אחר כך מניח שכל האובייקטים הזכאים כבר נעלמו. מה הבעיה?

ב-Java זו בקשה שה-JVM רשאית להתעלם ממנה, ולכן אין שום הבטחה שמשהו פונה. (ב-.NET GC.Collect() כן כופה איסוף, אבל לא מומלץ להשתמש בה.)

באיזה מובן GC הוא "יתרון", אם הוא דווקא צורך משאבים?

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

חזרה לתוכן העניינים

מעגלים של הפניות

מעגל הפניות (circular reference) נוצר כשאובייקטים מצביעים זה על זה בלולאה: A על B ו-B חזרה על A, או שרשרת ארוכה יותר שנסגרת על עצמה. השאלה היא מה קורה כשאף אחד מבחוץ כבר לא מצביע על המעגל.

התשובה תלויה בשיטה שבה מזהים אשפה, ויש שתי שיטות מרכזיות:

ספירת הפניות (reference counting)מעקב מהשורשים (tracing)
העיקרוןלכל אובייקט מונה של ההפניות אליו; כשהוא יורד לאפס האובייקט משוחררמתחילים מהשורשים ומסמנים כל מה שאפשר להגיע אליו; מה שלא סומן משוחרר
מעגל בלי הפניה מבחוץכל מונה במעגל נשאר לפחות 1, ולכן השיטה לבדה לא משחררת אותואף שורש לא מגיע למעגל, הוא לא מסומן, ומשוחרר כולו
מי משתמשCPython, כשיטה העיקרית, ולכן נוסף לו מנגנון נפרד שמחפש מעגליםה-JVM וה-CLR

לכן ב-Java וב-C# מעגלים פשוט אינם בעיה. ה-GC לא מתבלבל מהם ולא זורק חריגה, הם לא מחכים לקריאה מיוחדת ל-System.gc(), ואף אחד לא צריך לנתק את החוליות לפני שמוותרים על המבנה. השאלה היחידה היא האם שורש כלשהו עדיין מגיע אליהם.

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

Java
import java.lang.ref.WeakReference;

class Station {
    Station next;
}

public class Main {
    static Station entry;                       // static field: a GC root

    static int alive(WeakReference<?>[] probes) throws InterruptedException {
        for (int round = 0; round < 5; round++) {
            System.gc();
            Thread.sleep(40);
        }
        int n = 0;
        for (WeakReference<?> p : probes) if (p.get() != null) n++;
        return n;
    }

    public static void main(String[] argv) throws InterruptedException {
        Station a = new Station(), b = new Station(), c = new Station();
        a.next = b; b.next = c; c.next = a;     // a ring of three
        WeakReference<?>[] probes = {
            new WeakReference<>(a), new WeakReference<>(b), new WeakReference<>(c) };

        entry = b;                              // the root reaches one member only
        a = null; b = null; c = null;
        System.out.println("root -> b, alive: " + alive(probes));

        entry = null;                           // nothing outside the ring now
        System.out.println("no root, alive: " + alive(probes));
    }
}
פלט
root -> b, alive: 3
no root, alive: 0

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

את הקריאות החוזרות ל-System.gc() הכנסנו רק כדי שהתוצאה תופיע מיד בתוכנית קצרצרה. בלעדיהן הטבעת הייתה נעלמת בכל מקרה, באחד האיסופים הרגילים שסביבת הריצה מריצה ממילא.
תרחיש 11: עץ מסמך שבו כל צומת מכיר את ההורה

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

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

ב-Java כל העץ נעשה זכאי ויתפנה באיסוף הבא. במנגנון שמבוסס על ספירת הפניות בלבד, אף מונה לא היה יורד לאפס והעץ כולו היה נשאר בזיכרון.

טעויות נפוצות
  • אובייקטים במעגל שומרים זה על זה, ולכן לא ייאספו. ב-Java וב-C# מה שקובע הוא נגישות מהשורשים, לא כמה הפניות מצביעות על אובייקט.
  • לפני שמשחררים מבנה עם מעגלים צריך לאפס בו את כל השדות. מספיק שאף שורש לא יגיע אליו. הניתוק הידני מיותר.
  • מעגלים מזוהים רק כשמבקשים במפורש System.gc(). כל איסוף רגיל עובר מהשורשים ומפנה מעגלים לא נגישים.
  • מעגל לא נגיש מחכה בזיכרון עד שהתוכנית נסגרת. הוא מתפנה באיסוף הראשון שרץ אחרי שהוא נעשה לא נגיש.
  • ברגע שהמשתנים מקבלים null, האובייקטים במעגל נעלמים. הם רק נעשים זכאים. האיסוף בפועל קורה מאוחר יותר.
בדקו את עצמכם
ארבעה אובייקטים יוצרים טבעת W → X → Y → Z → W, ומשתנה מקומי במתודה שעדיין רצה מצביע על Y. כמה מהם זכאים לאיסוף?

אף אחד. מ-Y מגיעים ל-Z, ממנו ל-W וממנו ל-X, כך שכל הארבעה נגישים.

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

הם יישארו: המונה של כל אחד מהם הוא 1 ולא יגיע לאפס. ה-JVM מסמן מהשורשים, לא מגיע אליהם, ולכן משחרר את שניהם.

חזרה לתוכן העניינים

Mark-Sweep, דחיסה, העתקה ופיצול זיכרון

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

  • Copying (העתקה): מעבירים את האובייקטים החיים לאזור אחר, ואת כל האזור הישן מפנים במכה אחת. זה משתלם במיוחד כשרק מעט אובייקטים שורדים, כי העבודה תלויה במספר השורדים.
  • Mark-Sweep (סימון וניקוי): בשלב ה-Mark עוברים מהשורשים ומסמנים כל אובייקט נגיש; בשלב ה-Sweep עוברים על הערמה ומחזירים למאגר הפנוי כל מה שלא סומן. האובייקטים החיים נשארים במקומם, ולכן השטח הפנוי מפוזר ביניהם בחורים.
  • Mark-Compact (סימון ודחיסה, בגרסה המלאה Mark-Sweep-Compact): אחרי הסימון מצופפים את האובייקטים החיים לרצף אחד ומתקנים כל הפניה אליהם לכתובת החדשה. התוצאה היא שטח פנוי רציף.
Text
heap after Mark-Sweep (L = live, . = free)
L L . . L . L . . . L . L . .

heap after Mark-Compact
L L L L L L . . . . . . . . .
(every reference to a moved L now points to its new address)

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

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

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

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

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

ב-.NET יש אזור שבו הבעיה הזו בולטת במיוחד: ה-Large Object Heap (LOH), שאליו הולך כל אובייקט של 85,000 בתים או יותר. סביבת הריצה לא מצופפת אותו כברירת מחדל, ומפנה ממנו רק כשהיא אוספת את דור 2, ולכן חורים נשארים בו לאורך זמן.
תרחיש 12: עורך תמונות שלא מוצא מקום לשכבה חדשה

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

המשתמש מוסיף שכבה, והעורך מבקש מערך פיקסלים של 24 MB, שחייב לשבת ברצף.

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

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

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

מדדו שאחרי איסוף ב-Mark-Sweep פנויים 60% מהערמה, ובכל זאת הקצאה של מערך גדול נכשלה. מה קרה ומה יעזור?

פיצול: השטח הפנוי מחולק לחורים שאף אחד מהם לא גדול מספיק. דחיסה תצופף את האובייקטים החיים ותשאיר שטח פנוי רציף.

למה העתקה משתלמת דווקא באזור שבו רוב האובייקטים כבר מתים?

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

חזרה לתוכן העניינים

איסוף לפי דורות

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

המדידות בהרבה תוכניות מראות את אותה תמונה: רוב האובייקטים מתים צעירים, ומיעוט קטן חי הרבה זמן. איסוף לפי דורות (Generational Garbage Collection) בנוי על ההבחנה הזו ומחלק את הערמה לפי גיל.

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

  • שני אזורים עיקריים: Young Generation, ששם מתחיל את חייו כמעט כל אובייקט, ו-Old Generation, לשם מגיעים הוותיקים. ב-HotSpot הצעיר עצמו מתחלק לשלושה: Eden ועוד שני אזורי survivor.
  • איסוף בדור הצעיר (minor GC): תכוף, ובכל זאת מהיר. כמעט כל מה שנמצא שם כבר לא נגיש, ולכן נשאר רק להעתיק החוצה קומץ שורדים.
  • מעבר לדור הישן (promotion): מי ששורד מספר איסופים צעירים עובר לשם.
  • איסוף בדור הישן (major או full GC): נדיר יותר, וכל הפעלה שלו לוקחת יותר זמן.
  • ב-.NET: אותו עיקרון בדיוק, עם שלושה דורות ממוספרים 0, 1 ו-2.

התוכנית הבאה מחזיקה כ-4 MB של נתונים קבועים ובמקביל מייצרת המון מערכים זמניים. היא הורצה ב-Java 8 עם java -Xmx64m -Xmn4m -XX:+PrintGC Main (דור צעיר קטן במכוון, כדי לראות הרבה איסופים):

Java
import java.util.ArrayList;
import java.util.List;

public class Main {
    static List<int[]> settings = new ArrayList<>();   // long-lived data

    public static void main(String[] args) {
        long sum = 0;
        for (int k = 0; k < 4; k++) settings.add(new int[256 * 1024]);   // 4 MB kept
        for (int n = 0; n < 60_000; n++) {
            int[] scratch = new int[64];          // dies right after this iteration
            scratch[0] = n;
            sum += scratch[0];
        }
        System.out.println("sum " + sum);
    }
}
פלט
[GC (Allocation Failure)  2605K->2440K(65024K), 0.0594505 secs]
[GC (Allocation Failure)  5511K->4488K(65024K), 0.0202191 secs]
[GC (Allocation Failure)  7560K->4440K(65024K), 0.0557978 secs]
[GC (Allocation Failure)  7512K->4488K(65024K), 0.0750706 secs]
[GC (Allocation Failure)  7560K->4536K(65024K), 0.0473362 secs]
[GC (Allocation Failure)  7608K->4472K(65024K), 0.1382316 secs]
sum 1799970000

כל אחת מהשורות היא minor GC (כתוב GC, לא Full GC) שהופעל כש-Eden התמלא. בשורה הראשונה נשארו אחרי האיסוף כ-2.4 MB, כי באותו רגע עוד לא כל ארבעת המגה-בייטים של settings הוקצו.

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

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

הלוג מראה גם למה המודל מתאים לאובייקטים קצרי מועד (ephemeral): הדור הישן לא גדל לאורך הריצה, כלומר המערכים של scratch לא הגיעו אליו. כל מנה שלהם נוקתה כבר ב-minor GC הבא, ולא הספיקה להעמיס על הדור הישן.

ומה לא מצפים מהמודל?

  • עצירות נשארות: כל אחד מה-minor GC בלוג עצר את main לזמן קצר (העמודה האחרונה בשורה).
  • דליפה נשארת דליפה: אילו settings היה גדל בלי סוף, המערכים היו מגיעים לדור הישן ונשארים בו, כי הם נגישים.
  • אין קיצור דרך דרך המחסנית: new int[64] ב-Java מוקצה בערמה, והמודל גם לא שולח אובייקטים קצרי חיים לדור הישן כדי לחסוך איסופים.
  • אין שימוש בדיסק: ה-GC לא מוריד אובייקטים לקובץ כדי לפנות זיכרון.
תרחיש 13: פריים במשחק ומלאי של שחקן

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

כל האובייקטים האלה נולדים ב-Eden. כשמגיע האיסוף הצעיר, הווקטורים כבר לא נגישים ופשוט לא מועתקים; ה-Item נגיש ולכן מועתק לאזור survivor.

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

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

כי בדור הצעיר כמעט כל האובייקטים כבר לא נגישים, וה-GC צריך רק להעתיק את המעטים שנשארו.

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

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

חזרה לתוכן העניינים

עצירות Stop-The-World, אוספים של HotSpot וגודל ה-Heap

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

לעצירה הזו קוראים Stop-The-World event, והמשתמשים מרגישים אותה ישירות. בקשה שהגיעה לשרת באותו רגע מחכה, כפתור שנלחץ בממשק לא מגיב, ובגרף הביצועים מופיע שקע קצר. בסיכום, תוכנית עם GC נתקעת מדי פעם לרגע, וזמן הריצה הכולל שלה גדל.

ושלושה דברים שעצירה כזו איננה:

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

יש שלוש גישות לעצירות, לפי כמה מהעבודה נעשית כשהתוכנית עומדת:

עצירה מלאהאינקרמנטלי (Incremental GC)מקבילי (concurrent)
כמה עצירותאחת לכל איסוףהרבה, משולבות בריצת התוכניתמעט
אורך כל עצירהארוך: כל העבודה בבת אחתקצר: בכל פעם מטפלים רק בקטע מהעבודה, למשל מסמנים או מפנים חלק מהערמה, ובפעם הבאה ממשיכים מאותה נקודה בלי להתחיל מחדשקצר מאוד, אבל לא אפס
איפה רוב העבודהבתוך העצירהבתוך העצירות הקטנות; סך העבודה לפעמים גדל מעטבשרשורי GC שרצים לצד התוכנית
למי זה מתאיםכשעצירה ארוכה לא מפריעהיישומים אינטראקטיבייםכשכל עצירה חייבת להיות זעירה

ב-HotSpot יש כמה אוספים, וכל אחד ממקם אחרת את הפשרה בין תפוקה לאורך עצירה:

אוסףהאפליקציה עומדת?מה מיוחד בואיפה תפגשו אותו
Serialכן, לכל משך האיסוףשרשור GC אחד בלבדמכונות קטנות מאוד, שבהן ה-JVM בוחרת בו לבד
Parallelכן, לכל משך האיסוףכמה שרשורי GC עובדים יחד כדי לקצר את האיסוף; הכי טוב לתפוקה (throughput)ברירת המחדל של Java 8; עבודות שבהן עצירה ארוכה לא מזיקה
G1 (Garbage-First)חלקית: חלק מהעבודה רץ לצד התוכניתהערמה בנויה מהרבה regions קטנים בגודל אחיד; G1 מתחיל מה-regions שבהם הכי הרבה אובייקטים מתים, ומכאן השם; עובד בכמה שרשוריםערמות גדולות שיש להן יעד לאורך עצירה; ברירת המחדל מ-Java 9 על מכונות "בגודל שרת"
ZGC, Shenandoahכמעט לא: רוב האיסוף רץ לצד התוכניתעצירות קצרות מאודשירותים רגישים להשהיה

לעומת Mark-Sweep-Compact הקלאסי, ההבדל הוא ביחידת העבודה. הקלאסי לוקח בכל פעם את הערמה כולה ועושה עליה סימון, ניקוי ודחיסה; G1 מתייחס לכל region כיחידה ובוחר אילו מהם לאסוף, ולכן קל לו יותר לעמוד ביעד של זמן עצירה.

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

שאלה נפוצה: במה שונים Parallel ו-ZGC, נניח ב-Java 17? Parallel מקצר את האיסוף בכך שהוא מגייס לו הרבה ליבות, אבל כל זמן שהוא עובד האפליקציה מושבתת. ZGC הולך בדרך ההפוכה: הוא עובד לצד האפליקציה, ולכן העצירות שלו זעירות.

ב-.NET יש שני מצבים, GC של workstation ו-GC של server, ובנוסף אפשרות לאיסוף ברקע (background, concurrent).

גודל הערמה נקבע בשתי אפשרויות של ה-JVM: -Xms לגודל ההתחלתי ו--Xmx למקסימום. אפשר לראות את התרגום שלהן ואת האוסף שנבחר עם -XX:+PrintCommandLineFlags (כאן ב-Java 8):

Bash
java -Xms64m -Xmx512m -XX:+PrintCommandLineFlags -version
פלט
-XX:InitialHeapSize=67108864 -XX:MaxHeapSize=536870912 -XX:+PrintCommandLineFlags -XX:+UseCompressedClassPointers -XX:+UseCompressedOops -XX:-UseLargePagesIndividualAllocation -XX:+UseParallelGC 
openjdk version "1.8.0_452"
OpenJDK Runtime Environment (Temurin)(build 1.8.0_452-b09)
OpenJDK 64-Bit Server VM (Temurin)(build 25.452-b09, mixed mode)

InitialHeapSize הוא 64 MB בבתים ו-MaxHeapSize הוא 512 MB, ו-+UseParallelGC מאשר שב-Java 8 ברירת המחדל היא Parallel.

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

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

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

אין "GC לכל שרשור": האיסוף עובד על הערמה האחת, ובשלבים שבהם הוא עוצר, הוא עוצר את כולם. גם ה-TLAB של HotSpot לא משנה את זה. זה רק מקטע קטן מתוך הערמה שמוקצה לשרשור מסוים כדי שיוכל להקצות בלי להתחרות באחרים, וה-GC סורק אותו יחד עם כל השאר.

Thrashing הוא המצב שבו ה-GC כמעט לא מפסיק לרוץ. זה קורה כשהערמה תפוסה כמעט כולה באובייקטים שהתוכנית עוד מחזיקה: איסוף מצליח לפנות רק מעט, המקום הזה נגמר כמעט מיד, ומתחיל איסוף נוסף. המעבד עסוק בעיקר באיסופים, והתוכנית עצמה בקושי זזה.

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

תרחיש 14: שירות הצעות מחיר בזמן אמת מול דוח חודשי

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

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

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

תרחיש 15: הגדלת -Xmx שהחמירה את התלונות

בשירות הזמנות התלוננו על תקיעות של חצי שנייה. מישהו העלה את -Xmx מ-1 GB ל-6 GB, בהנחה שיותר זיכרון פירושו פחות עבודה ל-GC.

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

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

טעויות נפוצות
  • ה-GC רץ על ליבה משלו, אז זמני התגובה לא מושפעים ממנו. יש שלבים שבהם כל שרשורי התוכנית עומדים, וזה בדיוק מה שפוגע בזמני התגובה.
  • בזמן איסוף כל המחשב קופא. ה-GC שייך לסביבת הריצה של התוכנית עצמה, לא למערכת ההפעלה. רק השרשורים שלה עוצרים.
  • איסוף אינקרמנטלי מבטל את העצירות. הוא מחלק אותן לעצירות קצרות יותר, ובתמורה יש יותר עצירות.
  • Parallel רץ במקביל לאפליקציה ואילו ZGC עוצר אותה. זה הפוך. Parallel עוצר את האפליקציה ומשתמש בכמה שרשורים כדי לסיים מהר; ZGC עושה את רוב העבודה בזמן שהיא רצה.
  • G1 סופר הפניות, ועובד עם שרשור איסוף אחד. G1 עובד לפי נגישות מהשורשים, ומשתמש בכמה שרשורים.
  • ככל שהערמה גדולה יותר, האיסוף המלא קצר יותר ויש יותר מחזורים. שני החלקים הפוכים: יש פחות מחזורים, וכל איסוף מלא ארוך יותר.
  • כשיש הרבה שרשורים נוצרים פחות אובייקטים, כי הם חולקים זיכרון. כל שרשור מייצר אובייקטים משלו, ולכן קצב היצירה הכולל עולה וה-GC רץ יותר.
בדקו את עצמכם
בניטור של שרת רואים שבערך 85% מזמן המעבד הולך לאיסופים, וכל איסוף מפנה מעט מאוד מקום. מה שם התופעה ומה כנראה גרם לה?

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

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

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

מה קובעות -Xms ו--Xmx?

-Xms את גודל הערמה בהתחלה, ו--Xmx את הגודל המקסימלי שהיא יכולה להגיע אליו.

חזרה לתוכן העניינים

דליפות זיכרון ו-OutOfMemoryError

אם ה-GC מפנה כל מה שלא נגיש, מאיפה באות דליפות? מהפער בין "נגיש" לבין "נחוץ". ה-GC יודע לחשב רק את הראשון, ואין לו שום דרך לדעת מה התוכנית עוד מתכוונת להשתמש בו.

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

  • מטמון (cache) שאין לו שום מדיניות פינוי.
  • אוסף static שרק מוסיפים אליו ואף פעם לא מוציאים ממנו.
  • מאזינים (listeners), או ב-C# מטפלי אירועים (event handlers), שנרשמו ולא בוטל הרישום שלהם: מי שמחזיק את רשימת המאזינים שומר על כולם בחיים.

ובצד השני, מקרים שנשמעים כמו דליפה ב-Java אבל אינם:

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

שני כלים עוזרים לבנות מטמון בלי ליצור דליפה: WeakReference לא מחזיקה את האובייקט בחיים, ולכן מתאימה לפריטים שמותר לאבד, ו-SoftReference ב-Java מתרוקנת כשהזיכרון נעשה לחוץ.

מה קורה כשהדליפה ממשיכה? אם גם אחרי איסוף אין בערמה מקום לאובייקט חדש, ה-JVM זורקת OutOfMemoryError עם ההודעה Java heap space. ב-.NET המקבילה היא OutOfMemoryException.

שימו לב לשם: ב-Java זו Error ולא Exception. המשפחה הזו מסמנת תקלה חמורה בסביבת הריצה, שבדרך כלל לא מנסים לטפל בה בקוד.

ה-JVM לא מנסה "להציל" את המצב: היא לא מוחקת משתני static, לא מפעילה את התוכנית מחדש, ולא ממתינה שתהליכים אחרים יפנו זיכרון. הדוגמה הבאה הורצה עם java -Xmx24m Main, כלומר תקרה של 24 MB:

Java
import java.util.HashMap;
import java.util.Map;

public class Main {
    // memo of past results; nothing ever removes an entry
    static final Map<Integer, long[]> memo = new HashMap<>();

    static long[] compute(int key) {
        return memo.computeIfAbsent(key, k -> new long[64 * 1024]);   // 512 KB each
    }

    public static void main(String[] args) {
        int key = 0;
        try {
            while (true) {
                compute(key++);
                if (key % 16 == 0) System.out.println("entries: " + key);
            }
        } catch (OutOfMemoryError e) {
            int held = memo.size();
            memo.clear();                       // give the heap back before printing
            System.out.println(e.getClass().getSimpleName() + " (" + e.getMessage() + "), held " + held);
        }
    }
}
פלט
entries: 16
entries: 32
OutOfMemoryError (Java heap space), held 42

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

תרחיש 16: לשוניות צ'אט שנסגרו ולא נעלמו

באפליקציית צ'אט ב-C#, כל לשונית שיחה שנפתחת נרשמת לאירוע של רכיב התראות סטטי: NotificationHub.MessageArrived += tab.OnMessage;.

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

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

התיקון: בסגירת הלשונית לבטל את הרישום, NotificationHub.MessageArrived -= tab.OnMessage;.

טעויות נפוצות
  • בשפה עם GC דליפה היא בלתי אפשרית. אובייקט מיותר שעדיין נגיש לא נאסף. זו בדיוק דליפה.
  • כשהזיכרון נגמר, ה-JVM מאפסת שדות static או מתחילה את התוכנית מחדש. היא זורקת OutOfMemoryError, ולא נוגעת בשום שדה.
  • מעגל של אובייקטים שאין אליו הפניה מבחוץ הוא דליפה קלאסית ב-Java. מעגל כזה לא נגיש, ולכן נאסף כמו כל אשפה אחרת.
בדקו את עצמכם
שירות שומר כל תגובה של API חיצוני ב-static Map לפי כתובת הבקשה, בלי שום מחיקה. אחרי שבוע הוא נופל. איזו שגיאה צפויה, ולמה ה-GC לא עזר?

OutOfMemoryError (Java heap space). כל התגובות במפה נגישות מהשדה הסטטי, ולכן ה-GC לא רשאי לפנות אותן.

מתודה ממלאת ArrayList מקומית באלפי אובייקטים, מחשבת מהם מספר אחד ומחזירה רק אותו. האם הרשימה דולפת?

לא. אחרי שהמתודה חוזרת, שום שורש לא מוביל לרשימה, ולכן היא וכל מה שבתוכה זכאים לאיסוף.

חזרה לתוכן העניינים

Finalizers, PhantomReference וסגירת משאבים

זיכרון הוא התחום היחיד של ה-GC. ידית לקובץ, socket פתוח או מנעול לא נכללים בו: ה-GC לא ישחרר אותם, ואין לו מושג מתי הגיע זמנם.

משאבים כאלה סוגרים בצורה דטרמיניסטית, בנקודה ידועה בקוד: ב-Java עם try-with-resources על מחלקה שמממשת AutoCloseable, וב-C# עם using על IDisposable. כך זה נראה, גם כשנזרקת חריגה באמצע הבלוק:

Java
class Tape implements AutoCloseable {
    private final String label;
    Tape(String label) { this.label = label; System.out.println("open " + label); }
    void write(String s) { System.out.println(label + " <- " + s); }
    @Override public void close() { System.out.println("close " + label); }
}

public class TapeDemo {
    public static void main(String[] args) {
        System.out.println("start");
        try (Tape a = new Tape("audit"); Tape b = new Tape("backup")) {
            a.write("row 1");
            b.write("row 1");
            throw new IllegalStateException("disk full");
        } catch (IllegalStateException e) {
            System.out.println("caught: " + e.getMessage());
        }
    }
}
פלט
start
open audit
open backup
audit <- row 1
backup <- row 1
close backup
close audit
caught: disk full

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

אחרי שראיתם סגירה בנקודה ידועה, הנה ההפך הגמור: Finalizer. זה קוד שה-GC יפעיל על האובייקט ממש לפני שיפנה אותו; ב-Java זו המתודה finalize(), וב-C# התחביר ~Foo(), שבפועל מתורגם לדריסה של Finalize.

בגלל התחביר של C# קל לחשוב שזה destructor כמו ב-C++, אבל ההבדלים מהותיים:

destructor ב-C++finalizer ב-Java וב-C#
מתי הוא רץמיד, בנקודה ידועה בקודמתי שהוא, על שרשור finalizer נפרד, ואולי אף פעם
השפעה על פינוי הזיכרוןהזיכרון משתחרר מיד אחריוהפינוי נדחה: האובייקט מחכה בתור עד שה-finalizer ירוץ, ומתפנה רק באיסוף מאוחר יותר

מה קורה בפועל? שלב הסימון רץ כרגיל, וה-GC מזהה שהאובייקט כבר לא נגיש. אבל במקום להתפנות, האובייקט נכנס לתור של אובייקטים שמחכים ל-finalizer שלהם, ורק איסוף שיבוא אחרי שה-finalizer הסתיים ייקח את הזיכרון; כך האובייקט מחזיק מעמד לפחות מחזור איסוף אחד יותר מהדרוש.

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

שתי עובדות של גרסאות: ב-Java 9 finalize() קיבלה סימון deprecated, וב-Java 18 הסימון הוחמר ל"מיועד להסרה". בצד של C#, מי שמממש Dispose לפי התבנית קורא בסופו ל-GC.SuppressFinalize(this), וכך אובייקט שכבר ניקה את עצמו לא ממתין לשווא בתור ה-finalizer.

אם צריך לדעת שאובייקט נעלם כדי לנקות אחריו, Java מציעה כלי מדויק יותר: PhantomReference יחד עם ReferenceQueue. כך זה עובד, שלב אחרי שלב:

  1. יוצרים PhantomReference לאובייקט ומוסרים לה תור. ההפניה הזו לא נחשבת כהחזקה, ולכן לא מעכבת את האיסוף.
  2. התוכנית מפסיקה להחזיק את האובייקט. כשה-GC מגיע למסקנה שאין אליו שרשרת מהשורשים, הוא מוסיף את ה-PhantomReference לתור.
  3. שרשור שממתין על התור מקבל אותה ומבין מזה שהאובייקט איננו עוד. זה הרגע לנקות, לדוגמה לסגור ידית של מערכת ההפעלה שהאובייקט עטף.

לאורך כל הדרך get() של ה-PhantomReference מחזירה null. אין דרך להגיע דרכה לאובייקט, ולכן גם אין דרך לשמור אותו מחדש ולהחיות אותו. זה הבסיס של java.lang.ref.Cleaner, שנוסף ב-Java 9 כתחליף המומלץ ל-finalize().

Java
import java.lang.ref.PhantomReference;
import java.lang.ref.Reference;
import java.lang.ref.ReferenceQueue;

public class PhantomDemo {
    public static void main(String[] argv) throws InterruptedException {
        ReferenceQueue<Object> dead = new ReferenceQueue<>();
        Object left = new Object();
        Object right = new Object();
        PhantomReference<Object> pl = new PhantomReference<>(left, dead);
        PhantomReference<Object> pr = new PhantomReference<>(right, dead);

        System.out.println("pl.get() = " + pl.get() + ", right still usable: " + (right != null));
        left = null;                            // only "left" loses its last strong reference

        Reference<?> got = null;
        for (int i = 0; i < 10 && got == null; i++) {
            System.gc();
            got = dead.remove(80);              // wait up to 80 ms
        }
        System.out.println("queued: " + (got == pl ? "left" : got == pr ? "right" : "none"));
        System.out.println("more in queue: " + (dead.poll() != null));
        System.out.println(right.hashCode() == right.hashCode());   // keep right alive to here
    }
}
פלט
pl.get() = null, right still usable: true
queued: left
more in queue: false
true

רק left איבד את ההפניה החזקה האחרונה שלו, ולכן רק ה-PhantomReference שלו הגיע לתור. right מוחזק עד סוף main, וה-PhantomReference שלו לא מנע ולא קידם דבר.

סוג ההפניהמתי ה-GC רשאי לאסוף את האובייקטלמה משתמשים בה
רגילה (strong)אף פעם, כל עוד ההפניה עצמה נגישהברירת המחדל של כל משתנה ושדה
WeakReferenceבאיסוף הבא, אם רק הפניות חלשות מצביעות עליולשאול אם אובייקט עוד קיים, כמו החיישן בדוגמאות הקודמות, בלי להאריך את חייו
SoftReferenceכשהזיכרון מתחיל להיגמרמטמון שמוכן לוותר על פריטים בלחץ זיכרון
PhantomReferenceכמו WeakReference, ובנוסף היא אף פעם לא נותנת לקרוא אותו (get() מחזירה null)לקבל דרך ReferenceQueue הודעה על האיסוף ולנקות אחריו
תרחיש 17: מאגר חיבורים שהתרוקן

מחלקה ReportQuery לוקחת חיבור למסד נתונים בבנאי ומחזירה אותו למאגר רק ב-finalize(). שרת דוחות יוצר אלפי אובייקטים כאלה ביום ומפסיק להשתמש בכל אחד מהם אחרי שאילתה.

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

בינתיים כל עשרים החיבורים במאגר תפוסים, ובקשות חדשות נתקעות בהמתנה לחיבור. התיקון: ReportQuery מממשת AutoCloseable, משתמשים בה בתוך try-with-resources, והחיבור חוזר למאגר ביציאה מהבלוק.

טעויות נפוצות
  • בזכות finalize() האובייקט מתפנה מיד, בדיוק כמו עם destructor ב-C++. ההפך: ה-finalizer דוחה את הפינוי לפחות במחזור איסוף אחד, ואין מועד ידוע להרצתו.
  • אובייקט עם finalizer מדלג על שלב הסימון. הסימון מתבצע כרגיל; ה-finalizer מוסיף שלב לפני הפינוי.
  • finalizers עוזרים להוריד את צריכת הזיכרון. הם מחזיקים אובייקטים בזיכרון זמן רב יותר, ולכן מגדילים אותה.
  • אפשר לקרוא ל-get() של PhantomReference ולהציץ באובייקט לפני שהוא נעלם. get() שלה מחזירה תמיד null.
  • PhantomReference שומרת את האובייקט כל עוד היא קיימת. היא לא מחזיקה אותו בחיים; היא רק מקבלת הודעה אחרי שהוא נעשה לא נגיש.
  • כשאובייקט נאסף, ה-GC סוגר גם את הקבצים והנעילות שלו. ה-GC מטפל בזיכרון בלבד. משאבים סוגרים במפורש, עם try-with-resources או using.
בדקו את עצמכם
למה ניקוי שמבוסס על PhantomReference ו-ReferenceQueue לא יכול להחיות את האובייקט, בעוד ש-finalize() כן יכול?

finalize() רץ על האובייקט עצמו ויכול לשמור את this במקום נגיש. הקוד שמושך מהתור מקבל רק את ה-PhantomReference, ו-get() שלה מחזירה null, כך שאין לו הפניה לאובייקט.

מחלקה פותחת socket לשרת מרוחק. איפה ב-Java נכון לסגור אותו, ואיפה לא?

במתודה close() של AutoCloseable, כשמשתמשים במחלקה בתוך try-with-resources. לא ב-finalize(), שאין שום הבטחה מתי ירוץ ואם ירוץ.

חזרה לתוכן העניינים

Mutex: הדרה הדדית ותיאום בין שרשורים

מצב מרוץ (Race Condition) והקטע הקריטי

תוכנית יכולה להריץ כמה שרשורים (threads) בתוך אותו תהליך. לכל שרשור יש רצף פקודות ומחסנית משלו, אבל כולם עובדים על אותה ערמה: כל אובייקט שנוצר ב-new וכל שדה static נגישים לכולם באותה מידה.

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

מצב מרוץ (Race Condition) נוצר כששלושה תנאים מתקיימים יחד: שני שרשורים או יותר ניגשים לאותו משאב באותו פרק זמן, אחד מהם לפחות כותב אליו, ומה שיתקבל בסוף נקבע לפי הסדר שבו מערכת ההפעלה תזמנה אותם באותה ריצה.

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

  1. טעינה: מעתיקים את הערך הנוכחי של hits מהזיכרון.
  2. חישוב: מוסיפים 1 לעותק.
  3. שמירה: כותבים את התוצאה בחזרה לזיכרון.

בין כל שני שלבים שרשור אחר יכול להיכנס. כך נראית שזירה אחת שבה עבודה הולכת לאיבוד, כשהמונה מתחיל ב-41:

צעדשרשור Xשרשור Yhits בזיכרון
1טוען 41עוד לא התחיל41
2מושההטוען 41, כי X עוד לא שמר41
3מחשב 42 ושומרמושהה42
4סייםמחשב 42 ושומר42

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

מה שהשתבש בטבלה הוא ששני שרשורים היו באותו זמן באמצע אותו רצף של טעינה, חישוב ושמירה. רצף כזה, שנוגע בנתון משותף ושמותר שרק שרשור אחד יהיה בתוכו, מכונה קטע קריטי (critical section).

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

בתוכנית הבאה שלושה שרשורים מוכרים כרטיסים, וכל אחד מגדיל מונה מיליון פעמים. בסבב הראשון המונה מסומן volatile ואין נעילה; בסבב השני ההגדלה עטופה ב-synchronized:

Java
import java.util.concurrent.CountDownLatch;

public class TicketDemo {
    static volatile int soldVolatile = 0;      // visible to all threads, still not atomic
    static int soldGuarded = 0;                // protected by gate
    static final Object gate = new Object();

    // starts three sellers together and waits for all of them
    static void runThree(Runnable sales) throws InterruptedException {
        CountDownLatch go = new CountDownLatch(1);
        Thread[] sellers = new Thread[3];
        for (int i = 0; i < 3; i++) {
            sellers[i] = new Thread(() -> {
                try { go.await(); } catch (InterruptedException e) { return; }
                sales.run();
            });
            sellers[i].start();
        }
        go.countDown();
        for (Thread s : sellers) s.join();
    }

    public static void main(String[] argv) throws InterruptedException {
        runThree(() -> {
            for (int n = 0; n < 1_000_000; n++) soldVolatile++;    // load, add 1, store
        });
        runThree(() -> {
            for (int n = 0; n < 1_000_000; n++) {
                synchronized (gate) { soldGuarded++; }           // one seller inside at a time
            }
        });
        System.out.println("expected 3000000");
        System.out.println("volatile " + soldVolatile);
        System.out.println("guarded  " + soldGuarded);
    }
}
פלט
expected 3000000
volatile 1850765
guarded  3000000

המונה המוגן הגיע ל-3000000 בכל הרצה, וזה מובטח. המונה הלא מוגן משתנה מהרצה להרצה: בהרצות אחרות יצאו למשל 2997028 ו-2928611. אין גם הבטחה לטעות, כי הרצה בודדת יכולה במקרה לצאת נכונה, למשל במחשב עם מעט ליבות.

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

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

ניסיונות תיקון נפוצים שאינם עובדים:

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

איך מבחינים במרוץ לפי הסימפטום:

  • המספרים יוצאים שגויים, ושונים מהרצה להרצה: זה הסימן המובהק של מרוץ.
  • התוכנית קופאת ושום שרשור לא מתקדם: חשדו ב-Deadlock, שנגיע אליו בסוף הפרק, ולא במרוץ.
  • השרשורים מסתיימים בסדר אחר מזה שבו נוצרו: זה תקין לגמרי, ואין כאן באג.
  • התוכנית איטית כשיש בה הרבה שרשורים: זו בעיית ביצועים, לא מרוץ.
תרחיש 18: המושב האחרון באולם

במערכת הזמנות נשאר מושב פנוי אחד. שני שרשורים מטפלים בשתי הזמנות במקביל, ושניהם מריצים את אותו קוד: אם freeSeats > 0, אז freeSeats-- ומנפיקים כרטיס.

  1. X בודק, רואה 1 ומחליט להזמין.
  2. לפני ש-X מספיק להוריד, Y בודק, גם הוא רואה 1 ומחליט להזמין.
  3. X מוריד ל-0 ומנפיק כרטיס.
  4. Y מוריד למינוס 1 ומנפיק כרטיס שני לאותו מושב.

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

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

לא. כשאין אף כתיבה, כל סדר תזמון נותן אותה תוצאה, ולכן אין מרוץ ואין צורך בנעילה בלעדית.

מתכנת סימן את השדה visits כ-volatile, וכמה שרשורים ממשיכים להגדיל אותו ב-visits++ בלי נעילה. האם עדכונים עדיין יכולים לאבוד?

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

חזרה לתוכן העניינים

Mutex: בעלות, המתנה ומה הוא לא מבטיח

השם Mutex מגיע מ-MUTual EXclusion, כלומר הדרה הדדית (נקראת גם מניעה הדדית): מנגנון סנכרון שבכל רגע מחזיק בו לכל היותר שרשור אחד. אפשר לדמות אותו למפתח יחיד של חדר שרתים: מי שהמפתח אצלו נכנס, וכל השאר מחכים ליד הדלת.

החיים של Mutex מתחלקים לשלושה רגעים:

  • lock (acquire). ה-Mutex פנוי? השרשור שביקש לוקח אותו ונרשם כבעלים שלו.
  • חסימה. ה-Mutex בידי מישהו אחר? המבקש עומד במקום עד שיגיע תורו, ושום דבר אחר לא קורה לו: אין כניסה משותפת עם הבעלים, אין קפיצה מעל הקטע ואין חריגה.
  • unlock (release). זו זכות של הבעלים בלבד. מה שקובע הוא מי רכש, לא מי מחזיק הפניה לאובייקט, לא אם מדובר בשרשור הראשי ולא העדיפות.

הבעלות היא ההבדל המהותי בין Mutex לבין מנגנונים דומים לו, ונפגוש אותה שוב בכל שפה.

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

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

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

לצד Mutex יש שני מנגנונים שקל לבלבל ביניהם:

MutexSemaphore (סמפור)ReadWriteLock
כמה שרשורים בפנים יחדאחד בלבדעד מספר ההיתרים (permits) שהוגדרקוראים רבים יחד, או כותב יחיד לבד
בעלותיש, ורק הבעלים משחרראין: כל שרשור רשאי להחזיר היתריש, לכל אחת משתי הנעילות
מקרה שימוש טיפוסיהגנה על קטע קריטיתקרה על שימוש במשאב, למשל 8 הורדות במקבילנתון שנקרא כל הזמן ומתעדכן לעיתים רחוקות

סמפור עם היתר יחיד (סמפור בינארי) מתנהג כמעט כמו Mutex, אבל חסרה לו הבעלות: גם שרשור שלא רכש אותו יכול לשחרר אותו.

ב-ReadWriteLock (ב-Java המחלקה ReentrantReadWriteLock, וב-C# המחלקה ReaderWriterLockSlim) השאלה היא מה השרשור מבקש לעשות. מי שרק רוצה לקרוא מצטרף לקוראים שכבר בפנים, בתנאי שאין שם כותב; מי שרוצה לכתוב מחכה עד שהחדר מתרוקן לגמרי, גם מקוראים וגם מכותבים.

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

תרחיש 19: שני שרשורים ו-Mutex אחד
  1. השרשור exporter רוכש את ה-Mutex ומתחיל לכתוב לקובץ המשותף.
  2. השרשור importer מבקש את אותו Mutex בנעילה רגילה, לא בניסיון. ה-Mutex תפוס, ולכן importer נעצר ולא מתקדם אף שורה.
  3. שרשור שלישי, שמעולם לא רכש את ה-Mutex, מנסה בשלב הזה לשחרר אותו ונכשל עם חריגה, כי הוא לא הבעלים. ה-Mutex נשאר בידי exporter.
  4. exporter מסיים ומשחרר. importer מתעורר, הופך לבעלים ונכנס לקטע.
טעויות נפוצות
  • Mutex מתאים כשרוצים לתת לחמישה שרשורים לעבוד יחד על משאב. תקרה של N שרשורים היא התפקיד של Semaphore. Mutex מכניס תמיד שרשור אחד.
  • Mutex שומר על התוכנית מפני Deadlock. Mutex לא יודע דבר על מנעולים אחרים, ושימוש בכמה מהם בסדר לא עקבי הוא בדיוק מה שיוצר Deadlock.
  • נעילה מקצרת את זמן הריצה, כי השרשורים כבר לא מתנגשים. נעילה גורמת להמתנה. היא קונה נכונות במחיר של מקביליות.
  • אם הבעלים מתעכב, שרשור אחר יכול לשחרר את ה-Mutex במקומו. רק הבעלים משחרר. ניסיון של שרשור אחר נכשל.
  • Mutex נותן לקוראים לעבור יחד וחוסם רק את הכותבים. זה ReadWriteLock. Mutex לא מבחין בין קריאה לכתיבה.
  • גם כשכל השרשורים רק קוראים רשימה קבועה, צריך Mutex. בלי כתיבה אין מרוץ, ולכן אין מה לנעול.
בדקו את עצמכם
שירות פונה לממשק חיצוני שמרשה לכל היותר 4 חיבורים פתוחים בבת אחת. איזה מנגנון מגביל את השרשורים בדיוק לזה?

Semaphore עם 4 היתרים. Mutex היה מכניס שרשור אחד בלבד ומשאיר שלושה חיבורים מותרים בלי שימוש.

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

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

שרשור בעדיפות גבוהה רוצה לשחרר Mutex שרכש שרשור רקע. זה מותר?

לא. העדיפות לא משנה דבר. את ה-Mutex יכול לשחרר רק מי שרכש אותו.

חזרה לתוכן העניינים

Java: synchronized והמנעול שיש לכל אובייקט

ב-Java לא תמצאו מחלקה בשם Mutex. התפקיד מובנה בשפה עצמה: כל אובייקט נושא מנעול פנימי (intrinsic lock, שנקרא גם monitor), והמילה synchronized היא הדרך לתפוס אותו.

השאלה החשובה בכל synchronized היא איזה אובייקט ננעל בפועל:

איך כתובהמנעול שנתפסהמשמעות
synchronized (obj) { ... }המנעול של objאתם בוחרים את האובייקט במפורש
synchronized void m()המנעול של this, המופע שעליו המתודה נקראהקריאות על שני מופעים שונים לא מעכבות זו את זו
static synchronized void m()המנעול של אובייקט ה-Class, למשל Inventory.classיש אחד כזה לכל מחלקה, ולכן כל המופעים חולקים אותו

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

השני הוא כניסה חוזרת (reentrant). בתוכנית הבאה מתודה מוגנת קוראת למתודה מוגנת אחרת על אותו מנעול; נסו לנחש מה יודפס לפני שאתם קוראים את ההסבר.

Java
public class Inventory {
    private static final Object shelf = new Object();

    static void restock() {
        synchronized (shelf) {
            System.out.println("restock owns shelf: " + Thread.holdsLock(shelf));
            recordEntry();                         // asks for the same monitor again
            System.out.println("back in restock, still owns: " + Thread.holdsLock(shelf));
        }
        System.out.println("after the block, owns: " + Thread.holdsLock(shelf));
    }

    static void recordEntry() {
        synchronized (shelf) {                     // same thread, same monitor: no waiting
            System.out.println("recordEntry owns shelf: " + Thread.holdsLock(shelf));
        }
    }

    synchronized void count() {                    // instance method: monitor of this
        System.out.println("count owns this: " + Thread.holdsLock(this)
                + ", owns Inventory.class: " + Thread.holdsLock(Inventory.class));
    }

    static synchronized void report() {            // static method: monitor of Inventory.class
        System.out.println("report owns Inventory.class: " + Thread.holdsLock(Inventory.class));
    }

    public static void main(String[] argv) {
        restock();
        new Inventory().count();
        report();
    }
}
פלט
restock owns shelf: true
recordEntry owns shelf: true
back in restock, still owns: true
after the block, owns: false
count owns this: true, owns Inventory.class: false
report owns Inventory.class: true

restock מחזיקה את shelf וקוראת ל-recordEntry, שמבקשת בדיוק את אותו מנעול. אילו ה-JVM הייתה רואה בבקשה הזו עוד מתחרה, recordEntry הייתה מחכה לשחרור ש-restock לא תבצע לפני ש-recordEntry תחזור, והשרשור היה תקוע מול עצמו. בפועל ה-JVM מזהה שהמבקש כבר הבעלים, מעלה מונה פנימי ומכניסה אותו מיד.

כש-recordEntry יוצאת המונה יורד באחד, אבל המנעול עדיין בידי restock. רק אחרי היציאה מהבלוק החיצוני המונה מתאפס, ו-holdsLock מחזירה false.

השורה של count מראה שמתודת מופע נועלת את this ולא את אובייקט המחלקה, ו-report הסטטית מחזיקה את Inventory.class. הקוד עובר קומפילציה רגילה: אין איסור לקנן synchronized על אובייקט שכבר נעול, או לנעול אובייקט אחד מכמה מתודות.

החריגה IllegalMonitorStateException לא קשורה לכניסה חוזרת. המקרים שבהם היא נזרקת: שרשור מפעיל wait() או notify() על אובייקט שהמנעול שלו לא בידיו, או שרשור שאינו הבעלים קורא ל-unlock() של ReentrantLock, שנפגוש מיד.
תרחיש 20: מונה כללי ומונה אישי

במחלקה Ride יש static synchronized void countGlobal() וגם synchronized void countMine().

  • שני שרשורים קוראים ל-countGlobal דרך שני מופעים שונים של Ride: אחד ממתין לשני. שתי הקריאות נועלות את אותו Ride.class, ולא משנה דרך איזה מופע הן נעשו.
  • שני שרשורים קוראים ל-countMine, כל אחד על מופע אחר: הם רצים יחד, כי כל אחד נועל this אחר.
  • שרשור אחד בתוך countGlobal ושרשור אחר בתוך countMine: גם הם לא מעכבים זה את זה, כי אלה שני מנעולים נפרדים, של המחלקה ושל המופע.

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

טעויות נפוצות
  • שרשור שכבר נמצא בתוך synchronized על אובייקט ומבקש אותו שוב יחכה לעצמו. המנעול reentrant: הבעלים נכנס שוב מיד, ומונה הכניסות עולה.
  • הכניסה השנייה לאותו מנעול זורקת IllegalMonitorStateException. החריגה הזאת שמורה ל-wait או notify בלי מנעול ולשחרור בידי מי שאינו הבעלים, לא לכניסה חוזרת.
  • המהדר ידחה בלוק synchronized שנמצא בתוך בלוק אחר שנועל את אותו אובייקט. הקוד חוקי לגמרי ומתקמפל, כמו בדוגמה של restock.
  • למתודה static synchronized אין מה לנעול, כי אין לה this. יש לה מה לנעול: את אובייקט ה-Class, שיש ממנו אחד לכל מחלקה וכל המופעים חולקים אותו.
  • synchronized נועל את ה-Thread שמייצג את מי שקרא למתודה. הוא נועל את this, את אובייקט ה-Class או את האובייקט שבסוגריים. אובייקט ה-Thread לא קשור לעניין.
  • בספרייה הסטנדרטית של Java יש מחלקה בשם Mutex. אין כזו. את התפקיד ממלאים המנעול המובנה של כל אובייקט ו-ReentrantLock.
בדקו את עצמכם
המתודה synchronized void withdraw() של המחלקה Wallet קוראת מתוכה ל-static synchronized void logGlobal() של אותה מחלקה. אילו מנעולים השרשור מחזיק בזמן ש-logGlobal רצה?

שניים: את המנעול של המופע (this), שעוד לא שוחרר, ואת המנעול של Wallet.class.

בתוך synchronized (cache) { ... } נזרקת NullPointerException, ומישהו תופס אותה שתי מתודות למעלה. האם cache נשאר נעול?

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

חזרה לתוכן העניינים

Java: ReentrantLock, מנעול מפורש עם יותר שליטה

java.util.concurrent.locks.ReentrantLock הוא מנעול שהוא אובייקט רגיל: תופסים אותו בקריאה ל-lock() ומשחררים בקריאה ל-unlock().

בכללים הבסיסיים הוא מתנהג כמו synchronized: בעלים אחד בכל רגע, וכניסה חוזרת מותרת. לכל lock() נוסף של הבעלים צריך unlock() תואם.

מה שהוא מוסיף על synchronized:

  • tryLock(): התשובה מגיעה מיד. true אומר שעכשיו המנעול שלכם; false אומר שמישהו אחר מחזיק בו, ואתם ממשיכים לרוץ ובוחרים מה לעשות במקום.
  • tryLock(timeout, unit): אותה שאלה, עם נכונות לחכות פרק זמן מוגבל. התפנה המנעול בזמן הזה? תקבלו true; לא התפנה? false. בכניסה ל-synchronized אין דרך לקבוע תקרה כזו להמתנה.
  • lockInterruptibly(): ממתינים כרגיל, אבל שרשור אחר יכול לקרוא ל-interrupt() עליכם ולהוציא אתכם מההמתנה.
  • הוגנות (fairness): מנעול שנבנה ב-new ReentrantLock(true) נמסר לממתינים בסדר שבו הגיעו. ב-synchronized אין דרך לבקש סדר כזה.

על הגמישות משלמים באחריות. ReentrantLock לא יודע מתי יצאתם מבלוק, ולכן לא משתחרר מעצמו: אם חריגה קופצת בין lock() לבין unlock(), שורת השחרור פשוט לא מתבצעת.

התבנית שמונעת את זה: מיד אחרי lock() פותחים try, ואת unlock() מציבים ב-finally, שמתבצע בכל דרך יציאה.

Java
stockLock.lock();
try {
    // protected work: read and update the shared stock
} finally {
    stockLock.unlock();   // reached on every way out of the try
}

התוכנית הבאה משווה בין מתודה בלי finally לבין מתודה עם finally, כשבשתיהן הקטע המוגן זורק חריגה:

Java
import java.util.concurrent.locks.ReentrantLock;   // explicit lock, not a monitor

public class Gauge {
    static final ReentrantLock guard = new ReentrantLock();

    static void calibrateUnsafe() {
        guard.lock();
        checkSensor();                                 // throws, so the next line never runs
        guard.unlock();
    }

    static void calibrateSafe() {
        guard.lock();
        try {
            checkSensor();
        } finally {
            guard.unlock();                            // runs on normal exit and on an exception
        }
    }

    static void checkSensor() { throw new IllegalArgumentException("sensor offline"); }

    public static void main(String[] argv) {
        try { calibrateUnsafe(); } catch (IllegalArgumentException e) { System.out.println("unsafe -> " + e.getMessage()); }
        System.out.println("held after unsafe: " + guard.isLocked() + ", hold count " + guard.getHoldCount());
        guard.unlock();                                // main is still the owner, so this works

        try { calibrateSafe(); } catch (IllegalArgumentException e) { System.out.println("safe   -> " + e.getMessage()); }
        System.out.println("held after safe:   " + guard.isLocked());
    }
}
פלט
unsafe -> sensor offline
held after unsafe: true, hold count 1
safe   -> sensor offline
held after safe:   false

ב-calibrateUnsafe החריגה דילגה על unlock(). ה-catch ב-main תפס אותה, אבל תפיסת חריגה לא משחררת מנעולים, ולכן isLocked() מחזירה true ומונה ההחזקות הוא 1. מעכשיו כל שרשור אחר שיקרא ל-lock() ייתקע בלי סוף.

isLocked() עצמה לא ממתינה לדבר: היא רק מדווחת אם המנעול תפוס ברגע הקריאה. ב-calibrateSafe ה-finally רץ למרות החריגה, והמנעול חופשי.

finally אחראי לדבר אחד: ש-unlock() תרוץ גם כשהקטע המוגן נקטע בחריגה. שאר התכונות לא באות ממנו: הכניסה החוזרת והאפשרות להוגנות שייכות ל-ReentrantLock עצמו, וגם עם finally רק הבעלים יכול לשחרר.

התוכנית הבאה בודקת שלושה דברים נוספים: כניסה חוזרת, שני סוגי tryLock, וניסיון שחרור בידי שרשור זר:

Java
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;

public class Turnstile {
    public static void main(String[] argv) throws InterruptedException {
        ReentrantLock door = new ReentrantLock();
        door.lock();
        door.lock();
        door.lock();                                    // the owner may lock again
        System.out.println("main holds it " + door.getHoldCount() + " times");

        Thread visitor = new Thread(() -> {
            long t0 = System.nanoTime();
            boolean now = door.tryLock();               // answers at once
            System.out.println("visitor tryLock(): " + now);
            try {
                boolean later = door.tryLock(150, TimeUnit.MILLISECONDS);
                long ms = (System.nanoTime() - t0) / 1_000_000;
                System.out.println("visitor tryLock(150 ms): " + later + ", waited at least 150 ms: " + (ms >= 150));
            } catch (InterruptedException e) { return; }
            try {
                door.unlock();                          // visitor never owned it
            } catch (IllegalMonitorStateException e) {
                System.out.println("visitor unlock(): " + e.getClass().getSimpleName());
            }
        });
        visitor.start();
        visitor.join();

        door.unlock();
        door.unlock();
        System.out.println("after two unlocks, locked: " + door.isLocked());
        door.unlock();                                  // third unlock matches the third lock
        System.out.println("after three unlocks, locked: " + door.isLocked());
    }
}
פלט
main holds it 3 times
visitor tryLock(): false
visitor tryLock(150 ms): false, waited at least 150 ms: true
visitor unlock(): IllegalMonitorStateException
after two unlocks, locked: true
after three unlocks, locked: false

visitor לא נחסם לאורך זמן: tryLock() ענה false מיד, והגרסה עם הזמן ענתה false רק אחרי שחיכתה 150 מילישניות. הניסיון שלו לשחרר נכשל עם IllegalMonitorStateException ולא שינה דבר. main נעל שלוש פעמים, ולכן אחרי שני שחרורים המנעול עדיין תפוס, ורק השחרור השלישי פינה אותו.

synchronizedReentrantLock
כמה בעלים בו-זמניתאחדאחד
כניסה חוזרת של הבעליםמותרתמותרת, עם unlock לכל lock
איך משתחררלבד, ביציאה מהבלוק, גם בחריגהרק ב-unlock(), שכותבים ב-finally
לנסות בלי לחכותאי אפשרtryLock()
לחכות עם גבול זמןאי אפשרtryLock(timeout, unit)
סדר הוגן לממתיניםאיןnew ReentrantLock(true)
איפה מותר להשתמשבכל מתודה ובכל בלוקבכל מתודה, סטטית או של מופע
טווח ההגנהשרשורים בתוך תהליך JVM אחדשרשורים בתוך תהליך JVM אחד

השורה האחרונה חשובה: אף אחד מהשניים לא מתאם בין שני תהליכים שונים במחשב. לזה צריך מנעול שמערכת ההפעלה מנהלת, כמו ה-Mutex בעל השם של C# שבסעיף הבא. בשורה תחתונה: synchronized פשוט ועמיד בפני שכחה, ו-ReentrantLock גמיש יותר.

תרחיש 21: גיבוי מתוזמן שמוותר אם מישהו כבר באמצע

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

Java
if (backupLock.tryLock()) {          // false at once if someone holds it
    try {
        copySettings();
    } finally {
        backupLock.unlock();
    }
} else {
    log("backup already running, skipped");
}
  • המנעול פנוי: השרשור תופס אותו, מגבה ומשחרר ב-finally.
  • המנעול תפוס: tryLock() מחזירה false מיד, והשרשור רושם הודעה וממשיך בלי להיחסם.

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

טעויות נפוצות
  • synchronized דורש קריאה ל-unlock, ו-ReentrantLock משתחרר לבד בסוף הבלוק. המצב הפוך: synchronized משתחרר לבד, ו-ReentrantLock משתחרר רק ב-unlock.
  • חריגה בתוך synchronized משאירה את המנעול תפוס לתמיד. synchronized משתחרר בכל דרך יציאה. המנעול שנשאר תפוס הוא ReentrantLock שה-unlock שלו לא נמצא ב-finally.
  • נעילה הוגנת היא יכולת של synchronized, ו-ReentrantLock לא מציע אותה. גם זה הפוך: רק ל-ReentrantLock יש בנאי שמקבל fairness.
  • ReentrantLock מרשה לכמה שרשורים להחזיק אותו בבת אחת. יש לו בעלים אחד בלבד. Reentrant פירושו שאותו בעלים יכול להיכנס שוב, לא שזרים נכנסים איתו.
  • ReentrantLock מוגבל למתודות static. אפשר להשתמש בו בכל מתודה.
  • בלוק catch שתופס את החריגה משחרר בדרך את המנעול. catch לא נוגע במנעולים. רק unlock משחרר.
בדקו את עצמכם
שרשור קרא ל-lock() ארבע פעמים על אותו ReentrantLock ול-unlock() שלוש פעמים. שרשור אחר מבצע עכשיו tryLock(). מה הוא יקבל?

false. מונה ההחזקות של הבעלים עדיין 1, והמנעול מתפנה רק כשהמונה מגיע ל-0.

שרשור צריך את המנעול של רשימת ההמתנה, אבל מוכן לחכות לכל היותר חצי שנייה ואחר כך לוותר. synchronized או ReentrantLock?

ReentrantLock, עם tryLock(500, TimeUnit.MILLISECONDS). בכניסה ל-synchronized אין דרך לקבוע גבול להמתנה.

חזרה לתוכן העניינים

C#: הבלוק lock והמחלקה System.Threading.Mutex

ב-C# יש שני כלים עיקריים, והם שונים מאוד במשקל ובטווח שלהם.

הבלוק lock הוא מה שתכתבו ברוב המקרים. lock (obj) { ... } מבטיח שבכל רגע רק שרשור אחד מבצע את הבלוק, וכל שרשור אחר שמגיע אליו נעצר עד שהבלוק מתפנה.

אם תציצו בקוד שהמהדר מייצר, תמצאו קריאה ל-Monitor.Enter(obj) ואחריה try, שה-finally שלו קורא ל-Monitor.Exit(obj). מכאן שחריגה בתוך הבלוק לא משאירה את המנעול תפוס. כמו ב-Java הבעלים יכול להיכנס שוב (reentrant), וההגנה חלה רק על שרשורים באותו תהליך.

lock לא מוסיף שום מקביליות: הבלוק רץ באותו שרשור שהגיע אליו, על אותם משתנים משותפים, פשוט שרשור אחרי שרשור.

על מה נועלים? על שדה private readonly object שנוצר במיוחד לשם כך. נעילה על this, על אובייקט Type או על מחרוזת מסוכנת, כי גם קוד מחוץ למחלקה יכול להגיע לאותו אובייקט ולנעול אותו, ואז רכיבים שאינם קשורים חוסמים זה את זה.

C#
using System;
using System.Threading;

class Ledger
{
    private readonly object entryGuard = new object();   // private, used only for locking
    public int Balance;

    public void Deposit(int amount)
    {
        lock (entryGuard)                                 // Monitor.Enter ... finally Monitor.Exit
        {
            Balance += amount;
        }
    }
}

class Program
{
    static void Main()
    {
        var ledger = new Ledger();
        var clerks = new Thread[5];
        for (int i = 0; i < clerks.Length; i++)
        {
            clerks[i] = new Thread(() => { for (int k = 0; k < 20000; k++) ledger.Deposit(3); });
            clerks[i].Start();
        }
        foreach (var c in clerks) c.Join();
        Console.WriteLine($"balance = {ledger.Balance} (5 clerks x 20000 deposits x 3)");
    }
}
פלט
balance = 300000 (5 clerks x 20000 deposits x 3)

חמישה שרשורים, 20000 הפקדות לכל אחד ו-3 בכל הפקדה: 300000 בדיוק, בכל הרצה.

הגבלה נוספת: אסור לכתוב await בתוך גוף של lock, והמהדר עוצר עם שגיאה:

C#
using System.Threading.Tasks;

class Report
{
    private readonly object sync = new object();

    public async Task SaveAsync()
    {
        lock (sync)
        {
            await Task.Delay(10);   // not allowed inside lock
        }
    }

    static void Main() { }
}
פלט
Program.cs(11,13): error CS1996: Cannot await in the body of a lock statement

המחלקה System.Threading.Mutex היא סיפור אחר. זה אובייקט גרעין (kernel object) של מערכת ההפעלה, ולכן כל רכישה ושחרור כבדים יותר מאשר ב-lock. מה שמצדיק את המחיר הוא שאפשר לתת לו שם.

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

את העבודה עושות שתי מתודות, WaitOne לרכישה ו-ReleaseMutex לשחרור. הכי קל להכיר את הכללים שלהן בתוכנית שמנסה לשבור אותם:

C#
using System;
using System.Threading;

var gate = new Mutex();                     // no name: reachable only through this reference

var worker = new Thread(() =>
{
    gate.WaitOne();
    Console.WriteLine("worker: took the mutex and quits without ReleaseMutex");
});
worker.Start();
worker.Join();

try
{
    bool got = gate.WaitOne(2000);          // limited wait
    Console.WriteLine($"main: WaitOne returned {got}");
}
catch (AbandonedMutexException)
{
    Console.WriteLine("main: AbandonedMutexException, and main is the owner now");
}

gate.WaitOne();                             // owner again: re-entry, count is 2
gate.ReleaseMutex();
gate.ReleaseMutex();                        // one release for each acquisition
Console.WriteLine("main: released twice");

gate.WaitOne();                             // main owns it again
var intruder = new Thread(() =>
{
    try { gate.ReleaseMutex(); }
    catch (Exception e) { Console.WriteLine($"intruder: {e.GetType().Name}"); }
});
intruder.Start();
intruder.Join();
gate.ReleaseMutex();
Console.WriteLine("main: done");

// Monitor (what lock uses) refuses a non-owner too
var plain = new object();
try { Monitor.Exit(plain); }
catch (Exception e) { Console.WriteLine($"Monitor.Exit without owning: {e.GetType().Name}"); }
פלט
worker: took the mutex and quits without ReleaseMutex
main: AbandonedMutexException, and main is the owner now
main: released twice
intruder: ApplicationException
main: done
Monitor.Exit without owning: SynchronizationLockException
  1. worker קורא ל-WaitOne(). ה-Mutex פנוי, ולכן הקריאה חוזרת מיד ו-worker הוא הבעלים. אילו מישהו אחר היה מחזיק בו, WaitOne() הייתה חוסמת עד שיתפנה.
  2. worker מסתיים בלי ReleaseMutex. ה-Mutex נשאר רשום על בעלים שכבר לא קיים, ולכן הוא נטוש (abandoned).
  3. main קורא ל-WaitOne(2000), הגרסה שמוותרת אחרי זמן מוגבל. הוא לא נתקע, וגם לא מקבל את ה-Mutex בשקט: הבעלות עוברת אליו, אבל הקריאה זורקת AbandonedMutexException, ולכן השורה WaitOne returned לא מודפסת.
  4. main כבר הבעלים, ולכן WaitOne() נוסף הוא כניסה חוזרת. אחריו נדרשים שני ReleaseMutex, אחד לכל רכישה.
  5. intruder מנסה לשחרר Mutex שלא רכש, ונדחה עם ApplicationException.

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

השורה האחרונה בפלט היא ההשוואה ל-lock: גם Monitor.Exit מסרב למי שלא מחזיק במנעול, עם SynchronizationLockException.

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

השימוש המוכר ביותר ב-Mutex בעל שם הוא אפליקציה שמותר להריץ ממנה עותק אחד בלבד. הבנאי new Mutex(true, name, out bool createdNew) מבקש ליצור Mutex בשם הזה ולקבל עליו בעלות, ו-createdNew מספר אם הוא באמת נוצר עכשיו.

רק התהליך שיצר את ה-Mutex מקבל true. כל תהליך שמגיע כשהוא כבר קיים מקבל false, ומבין שעותק אחר כבר פועל. בתוכנית הבאה העותק הראשון מפעיל את עצמו שוב כתהליך נפרד, כדי לראות את שני הצדדים בהרצה אחת:

C#
using System;
using System.Diagnostics;
using System.Threading;

// Run once with no arguments. The program then starts a second copy of itself
// (a separate OS process) while the first copy still holds the named mutex.
bool isSecond = args.Length > 0;
string who = isSecond ? "copy 2" : "copy 1";

using var single = new Mutex(true, @"Local\Fabrikam.Planner.OneCopy", out bool createdNew);
Console.WriteLine($"{who} (pid {Environment.ProcessId}): createdNew = {createdNew}");

if (!createdNew)
{
    Console.WriteLine($"{who}: another copy is running, exiting");
    return;
}

if (!isSecond)
{
    var p = Process.Start(new ProcessStartInfo(Environment.ProcessPath!, "second") { UseShellExecute = false });
    p!.WaitForExit();
}
single.ReleaseMutex();
Console.WriteLine($"{who}: released the mutex and finished");
פלט
copy 1 (pid 12320): createdNew = True
copy 2 (pid 28700): createdNew = False
copy 2: another copy is running, exiting
copy 1: released the mutex and finished

מספרי התהליך (pid) שונים, כלומר אלה באמת שני תהליכים, ובכל זאת השני מצא את ה-Mutex של הראשון לפי השם. הקידומת Local\ מגבילה את השם לסשן של המשתמש הנוכחי, והקידומת Global\ משתפת אותו בין כל הסשנים במחשב.

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

lock (Monitor)System.Threading.Mutex
מי רואה את הנעילהשרשורים של אותו תהליךאותו תהליך, ועם שם גם תהליכים אחרים במחשב
עלותנמוכה, בתוך סביבת הריצהגבוהה יותר, אובייקט של מערכת ההפעלה
תפיסה ושחרוראוטומטיים סביב הבלוקWaitOne ו-ReleaseMutex במפורש
שחרור בידי מי שאינו הבעליםSynchronizationLockException מ-Monitor.ExitApplicationException
בעלים שנעלם בלי לשחררלא רלוונטי, השחרור אוטומטיהממתין הבא מקבל AbandonedMutexException
תרחיש 22: לחיצה כפולה על עורך תמונות

משתמש לוחץ פעמיים על הסמל של עורך תמונות שנכתב ב-C#, ומערכת ההפעלה מפעילה שני תהליכים כמעט באותו רגע.

  1. תהליך א' מבצע new Mutex(true, "Pixelwise.Editor", out bool createdNew). עדיין אין Mutex בשם הזה, ולכן הוא נוצר ו-createdNew הוא true.
  2. תהליך ב' מבצע את אותה שורה. מערכת ההפעלה מוצאת Mutex קיים בשם הזה, ו-createdNew הוא false.
  3. תהליך ב' מציג הודעה ונסגר, והמשתמש נשאר עם חלון אחד.

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

טעויות נפוצות
  • lock על אובייקט static מגן גם בין שני עותקים של התוכנית. כל תהליך מחזיק עותק משלו של האובייקט. lock תקף בתוך תהליך אחד בלבד.
  • Mutex בלי שם משותף אוטומטית לכל התהליכים. בלי שם אין לתהליך אחר דרך למצוא אותו. השיתוף בין תהליכים מגיע רק מהשם.
  • אם הבעלים נגמר בלי לשחרר, הממתינים תקועים לתמיד, או לחלופין הבא בתור ממשיך כרגיל בלי לדעת דבר. שתי האפשרויות שגויות. הממתין הבא מקבל את ה-Mutex, יחד עם AbandonedMutexException כאזהרה.
  • ה-GC ישחרר Mutex שאף אחד כבר לא מחזיק אליו הפניה. ה-GC אחראי לזיכרון בלבד. נעילה משתחררת בידי הבעלים, או עוברת הלאה כנטושה.
  • כל שרשור באותו תהליך רשאי לקרוא ל-ReleaseMutex. רק הבעלים. כל שרשור אחר מקבל ApplicationException.
  • lock מפעיל את הבלוק בשרשור נפרד, או מריץ אותו בכל השרשורים במקביל. הבלוק רץ בשרשור שהגיע אליו, ושרשורים אחרים מחכים בתור עד שהוא מתפנה.
בדקו את עצמכם
שתי תוכניות C# נפרדות כותבות שורות לאותו קובץ CSV של דוחות. מספיק שכל אחת תעטוף את הכתיבה ב-lock?

לא. lock לא חוצה את גבול התהליך. צריך Mutex עם שם ששתי התוכניות מכירות: WaitOne לפני הכתיבה ו-ReleaseMutex אחריה.

שרשור שהחזיק Mutex סיים את העבודה שלו ויצא לפני ש-ReleaseMutex נקראה. מה יקבל השרשור הבא שקורא ל-WaitOne?

ה-Mutex עובר אליו והוא הבעלים החדש, אבל WaitOne זורקת אצלו AbandonedMutexException. כדאי לבדוק שהנתונים המוגנים שלמים לפני שממשיכים.

חזרה לתוכן העניינים

Deadlock: המתנה מעגלית וסדר נעילה קבוע

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

המתכון הנפוץ הוא שני שרשורים שצריכים אותם שני מנעולים ותופסים אותם בסדר הפוך. נניח מנעולים בשם scanner ו-printer:

רגעcopyJobfaxJob
1תופס את scannerתופס את printer
2מבקש את printer, שבידי faxJob, ונעצרמבקש את scanner, שבידי copyJob, ונעצר
3ממתיןממתין

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

Java
public class PrintShop {
    static final Object printer = new Object();
    static final Object scanner = new Object();

    static void nap() { try { Thread.sleep(80); } catch (InterruptedException e) { } }

    public static void main(String[] argv) throws InterruptedException {
        Thread copyJob = new Thread(() -> {
            synchronized (scanner) { nap();
                synchronized (printer) { System.out.println("copyJob finished"); } }
        });
        Thread faxJob = new Thread(() -> {
            synchronized (printer) { nap();                 // reverse order: printer first
                synchronized (scanner) { System.out.println("faxJob finished"); } }
        });
        copyJob.setDaemon(true);                            // lets the JVM exit despite the stuck threads
        faxJob.setDaemon(true);
        copyJob.start(); faxJob.start();
        copyJob.join(1500); faxJob.join(1500);              // wait 1.5 s at most
        System.out.println("copyJob " + copyJob.getState() + ", faxJob " + faxJob.getState());
    }
}
פלט
copyJob BLOCKED, faxJob BLOCKED

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

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

Java
public class PrintShopFixed {
    static final Object printer = new Object();
    static final Object scanner = new Object();

    static void nap() { try { Thread.sleep(80); } catch (InterruptedException e) { } }

    // the single agreed order: scanner, then printer
    static void useBoth(String job) {
        synchronized (scanner) { nap();
            synchronized (printer) { System.out.println(job + " finished"); } }
    }

    public static void main(String[] argv) throws InterruptedException {
        Thread copyJob = new Thread(() -> useBoth("copyJob"));
        Thread faxJob = new Thread(() -> useBoth("faxJob"));
        copyJob.start(); faxJob.start();
        copyJob.join(); faxJob.join();
        System.out.println("both jobs ended");
    }
}
פלט
copyJob finished
faxJob finished
both jobs ended

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

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

שתי הגנות משלימות:

  • המתנה עם תקרת זמן: tryLock(timeout, unit) ב-Java או WaitOne(timeout) ב-C#. מי שלא קיבל את המנעול בזמן משחרר את מה שכבר בידיו ומנסה שוב מאוחר יותר.
  • פחות זמן ופחות מנעולים: קטעים קריטיים קצרים, ומעט מנעולים שמוחזקים בבת אחת, מצמצמים את ההזדמנויות להיתקע.

כמה דברים שאינם קשורים ל-Deadlock, לא כגורם ולא כתרופה:

הטענהמה נכון
שרשור שתופס פעמיים את אותו מנעול ייתקעלא. כל ארבעת המנגנונים שראינו בפרק, synchronized, ReentrantLock, lock של C# ו-Mutex, מכניסים את הבעלים שוב בלי המתנה
שני שרשורים שקוראים אותם נתונים יחסמו זה את זההקריאה עצמה לא גורמת לחסימה הדדית
יותר מנעולים מליבות מעבד יוצרים קיפאוןהיחס הזה לא רלוונטי. Deadlock הוא עניין של סדר ההמתנה, לא של חומרה
נעילה בסדר אקראי, תוספת שרשורים או עדיפות שווה לכולם ימנעו קיפאוןאף אחד מאלה לא שובר המתנה מעגלית. סדר אקראי אפילו מגדיל את הסיכוי שבשלב כלשהו שני שרשורים ינעלו בסדר הפוך, ומשם הדרך ל-Deadlock קצרה

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

תרחיש 23: העברת כסף בין שני ארנקים

המתודה move(source, target, sum) נועלת קודם את source ואחר כך את target.

  1. שרשור א' מעביר מארנק 12 לארנק 30, ובאותו רגע שרשור ב' מעביר מארנק 30 לארנק 12.
  2. א' נועל את 12 ומבקש את 30; ב' נועל את 30 ומבקש את 12.
  3. כל אחד מחזיק את מה שהשני צריך: Deadlock.

התיקון: לנעול לא לפי התפקיד (מקור ויעד) אלא לפי מספר הארנק, תמיד את הקטן קודם. כעת שני השרשורים מתחילים בארנק 12, אחד מהם מקבל אותו, והשני פשוט מחכה שהראשון יסיים.

טעויות נפוצות
  • Deadlock קורה כששרשור מבקש שוב מנעול שכבר נמצא בידיו. המנעולים הנפוצים reentrant. Deadlock דורש לפחות שני שרשורים שממתינים זה לזה.
  • כשיש יותר מנעולים מליבות, חלק מהשרשורים ייתקעו. מספר הליבות לא משפיע. הבעיה היא המעגל בהמתנה.
  • נעילה בסדר אקראי מפזרת את העומס ולכן מונעת קיפאון. סדר אקראי הוא בדיוק סדר לא עקבי, וזה מה שיוצר את המעגל.
  • המטרה של סדר נעילה קבוע היא שכל ממתין יקבל את המנעול בסופו של דבר. זו הוגנות. סדר נעילה נועד לשבור את ההמתנה המעגלית.
בדקו את עצמכם
סדר המנעולים המוסכם במערכת הוא P, Q, R. שרשור 1 נועל P ואז R, שרשור 2 נועל Q ואז R, ושרשור 3 נועל R ואז Q. מי שובר את הכלל, ומה התיקון?

שרשור 3, כי הוא תופס את R לפני Q. צריך להפוך אצלו את הסדר: קודם Q ואחר כך R.

מתודה רקורסיבית נועלת ReentrantLock בכל קריאה, כך שהשרשור קורא ל-lock() שלוש פעמים ברצף לפני שהוא משחרר. יש כאן Deadlock?

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

חזרה לתוכן העניינים

סיכום

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

רפלקציה

  • מה זה? בחינה של מחלקות, שדות ומתודות בזמן ריצה, מתוך המטא-דאטה שסביבת הריצה מחזיקה. היא לא מריצה מחרוזות קוד כמו eval, לא שומרת אובייקטים כמו serialization ולא נוגעת בקוד המקור.
  • איך מגיעים לאובייקט Class? מתוך מופע ב-getClass(), מתוך הקוד ב-Foo.class, או ממחרוזת ב-Class.forName. האחרונה מריצה את האתחול הסטטי של המחלקה אבל לא בונה ממנה מופע, ונכשלת ב-ClassNotFoundException כשהשם לא קיים.
  • ומה ב-C#? GetType(), typeof ו-Type.GetType, כשהאחרונה מחזירה null במקום לזרוק.
  • getMethods או getDeclaredMethods? הראשונה רואה רק public, אבל גם מה שהגיע בירושה; השנייה רואה הכול, כולל private, אבל רק מה שנכתב במחלקה עצמה. השדות מתחלקים באותו אופן.
  • איך מפעילים ויוצרים? invoke מקבלת את האובייקט ואת הארגומנטים, ו-null במקום האובייקט כשהמתודה סטטית. אם המתודה עצמה נכשלה, החריגה שלה מגיעה בתוך InvocationTargetException, ובנאי מפעילים דרך getDeclaredConstructor().newInstance().
  • ומה עם private? מבקשים את השדה ב-getDeclaredField ופותחים אותו ב-setAccessible(true), ורק אז קוראים או כותבים; בלי הפתיחה מתקבלת IllegalAccessException. זה כוח שעוקף כימוס, ולכן משתמשים בו בזהירות בקוד ייצור.
  • איפה פוגשים את זה? JUnit, מסגרות להזרקת תלות ומערכות תוספים מגלות מחלקות ומפעילות אותן ברפלקציה, ונשענות על אנוטציות שנשמרות עד זמן הריצה (RetentionPolicy.RUNTIME). Annotation Processing עושה עבודה דומה כבר בהידור, וכך חוסך רפלקציה.
  • ומעבר לקריאה? Proxy דינמי הוא אובייקט שנולד בזמן ריצה, מממש ממשקים ומנתב כל קריאה אליו למטפל, והוא הבסיס ל-AOP בזמן ריצה. ספריות כמו ASM הולכות צעד נוסף ועורכות את ה-bytecode של המחלקה.
  • כמה זה עולה בזמן? כל קריאה מחפשת, בודקת הרשאות ועוטפת ערכים (boxing), ולכן שומרים את ה-Method במטמון.
  • ומה עוד יכול להישבר? המהדר לא בודק קריאה רפלקטיבית בכלל, לא שמות ולא טיפוסים של ארגומנטים או ערכי החזרה, כך שהטעויות צצות רק בזמן ריצה. obfuscation משנה שמות ושובר אותה, וטעינה מחדש דרך Class Loader חדש משאירה הפניות ישנות מחוברות לגרסה הקודמת.

איסוף אשפה

  • מי נשאר בחיים? כל מה שאפשר להגיע אליו בשרשרת הפניות משורש: משתנה מקומי של מתודה שרצה, שדה static או שרשור פעיל. כל השאר מועמד לשחרור, גם אם הוא חלק ממעגל הפניות סגור.
  • מתי זה קורה? כשה-GC מחליט, ו-System.gc() רק מבקשת. היתרון הגדול הוא שאין קוד שחרור, ולכן אין שחרור כפול או שכוח.
  • מה נשאר אחרי הניקוי? Mark-Sweep משאיר רווחים מפוזרים בין האובייקטים החיים, ודחיסה מזיזה אותם לרצף אחד. כשהזיכרון מפוצל, קשה יותר למצוא מקום להקצאה והאיסופים מתארכים.
  • למה דורות? כי רוב האובייקטים קצרי ימים. אוספים את הצעירים הרבה, מעבירים את מי ששרד לדור הוותיק ומבקרים בו לעיתים רחוקות; זה חוסך עבודה, אבל עצירות ודליפות לא נעלמות.
  • כמה התוכנית עומדת? Stop-The-World עוצר את כל שרשורי התוכנית, ואיסוף אינקרמנטלי מחליף עצירה ארוכה אחת בהרבה קצרות.
  • ומה ההבדל בין האוספים? Parallel מקצר את העצירה בעזרת כמה שרשורי איסוף, אבל התוכנית עדיין עומדת. G1 עובד אזור אחרי אזור ובוחר קודם את אלה שרובם אשפה, ו-ZGC מבצע את רוב העבודה בזמן שהתוכנית ממשיכה לרוץ.
  • מה קובע את התדירות? ערמה גדולה מתמלאת לאט ולכן נאספת פחות, אבל כשמגיע איסוף מלא הוא ארוך. הרבה שרשורים מקצים יותר ולכן גורמים ליותר איסופים, ובקצה נמצא Thrashing, שבו ה-GC כמעט לא מפסיק לעבוד.
  • איך בכל זאת דולף זיכרון? כשהתוכנית שוכחת הפניה במקום שחי לאורך זמן: אוסף static, מטמון, או מאזין שלא הוסר. כשהערמה מתמלאת עד הסוף מתקבלת OutOfMemoryError.
  • ומה עם ניקוי משאבים? finalize אינה destructor: אין לדעת מתי תרוץ, והיא רק מאחרת את שחרור האובייקט. לכן סוגרים משאבים ב-try-with-resources או ב-using.
  • ואם צריך לדעת שאובייקט כבר נאסף? רושמים עליו PhantomReference יחד עם ReferenceQueue, וההודעה מגיעה דרך התור; את האובייקט עצמו אי אפשר לקבל ממנה, כי ה-get() שלה מחזיר null בכל מקרה. Cleaner הוא מעטפת נוחה מעל המנגנון הזה.

סנכרון בין שרשורים

  • מתי יש בעיה? כשכמה שרשורים נוגעים באותו נתון, לפחות אחד כותב, והתוצאה משתנה לפי התזמון. נעילה אחת שמקיפה גם את הקריאה וגם את הכתיבה פותרת אותה.
  • איזה מנגנון לבחור? Mutex לשרשור יחיד בפנים, עם בעלים שרק הוא משחרר; Semaphore ל-N היתרים בלי בעלים; ReadWriteLock כשיש הרבה קוראים ומעט כותבים.
  • ומה ב-Java? synchronized בוחר את המנעול לפי ההקשר (האובייקט בסוגריים, this, או ה-Class במתודה סטטית), מכניס שוב את הבעלים ומשחרר מעצמו. ReentrantLock דורש unlock ב-finally ונותן בתמורה tryLock, המתנה מוגבלת בזמן והוגנות, ושחרור בידי זר נגמר ב-IllegalMonitorStateException.
  • ומה ב-C#? lock לשרשורים באותו תהליך, ו-Mutex בעל שם כשצריך לתאם בין תהליכים, למשל לאפליקציה בעותק יחיד לפי createdNew. ReleaseMutex מזר זורקת ApplicationException, ובעלים שנעלם משאיר לבא אחריו AbandonedMutexException.
  • ו-Deadlock? מעגל של שרשורים שכל אחד מחזיק משהו שהבא צריך, שנוצר מסדר נעילה לא אחיד. סדר קבוע שובר את המעגל, ו-timeout וקטעים קריטיים קצרים מקטינים את הסיכון.