Garbage Collector
new מבקשים אובייקט, והגארבג' קולקטור אחראי להקצות את הזיכרון ולהחזיר אותו למערכת כשאין בו צורך.GC.Collect(0) מנקה רק את 0. לא מומלץ להפעיל אותה באופן קבוע, כי היא עוצרת את התוכנית ומשבשת את הסטטיסטיקות הפנימיות.פרקי ההרצאה: Garbage Collector
תמלול ההרצאה: Garbage Collector
הטקסט המלא של הדקות הראשונות בהרצאה «Garbage Collector» בקורס הווידאו של PracticU – כתוביות בעברית עם זמן התחלה לכל פסקה. כך תוכלו לקרוא ולחפש את הנושאים לפני שמתחילים ללמוד.
אנחנו מגיעים לנושא שהזכרנו אותו מדי פעם והנושא הזה נקרא garbage collector. קודם כל בואו נבהיר מה זה ה garbage collector. ה garbage collector זהו מנגנון שקיים בדוטנט וגם בהרבה שפות אחרות כמו בג'אווה כמו בvisual basic ומה שה garbage
collector הזה עושה הוא אחראי על הקצאה של אובייקטים כאשר אנחנו רוצים אובייקט אבל הוא גם אחראי על שחרור הזיכרון של האובייקטים והחזרת הזיכרון למערכת כך שבעתיד אם אנחנו נרצה עוד אובייקטים אז נוכל להשתמש בזיכרון של אובייקטים ישנים.
כאשר אנחנו רוצים אובייקט כל מה שאנחנו עושים זה משתמשים באופרטור ה-new. אנחנו רושמים person p=new person בוא נניח. מי שאחראי להביא לנו את האובייקט זה מנגנון ה garbage collector.
כאשר הגארבג' קולקטור מוצא לנכון להיפטר מהזיכרון של האובייקט וכבר אנחנו הולכים לראות מתי הוא עושה את זה אז הגארבג' קולקטור נפטר מהאובייקט הזה או יכול להקצות עליו אובייקטים אחרים ולהשתמש באזור זיכרון שלו.
הגארבג' קולקטור עובד רק עם זיכרון המנג'ד היפ הוא לא עובד עם זיכרון הסטאק סגמנט סטאק מיועד למשתנים לוקאליים של פונקציות המנג' דהיפ מיועד לאובייקטים מסוג רפרנס סטייל, כלומר כאלה שיצרנו אותם לדוגמה על ידי קלאס, על ידי דלגייט.
אז דבר ראשון אנחנו הולכים לראות איך הגארבג' קולקטור עובד מבחינה פנימית. הגארבג' קולקטור מגדיר שלושה אזורי זיכרון שנקראים ג'נריישן 0, ג'נריישן 1 וג'נריישן 2. כל אזור זיכרון כזה הוא יותר גדול מהקודם.
יש כל מיני מאמרים באינטרנט לגבי כמה הגדלים שלהם ג'נריישן 0 לפי כמה מאמרים זה באזור ה-256 קילו, ג'נריישן 1 זה באזור ה-2 מגה, ג'נריישן 2 זה באזור ה-10 מגה.
קודם כל האזורי זיכרון האלה יכולים להשתנות על ידי הגארבץ' קולקטור לפי מה שהוא מוצא לנכון ולא הייתי סומך על המספרים האלה. יכול להיות שבמערכות שונות המספרים האלה יהיו שונים.
אבל בגדול אנחנו יודעים בוודאות, ג'נריישן 0 הכי קטן, אחר כך ג'נריישן 1 הרבה יותר גדול ממנו וג'נריישן 2 הרבה יותר גדול משניהם. כאשר הגארבץ' קולקטור יוצר אובייקט הוא יוצר אותו בתוך ג'נריישן 0. זאת אומרת, אם אני עכשיו בא ואומר אני רוצה אובייקט person p=new person, אין שום בעיה, הגארבץ' קולקטור יוצר לי אותו בתוך ג'נריישן 0.
כמובן שיש לי עוד הרבה מקום בג'נריישן 0. אז אני בא ואני אומר, טוב, אני רוצה גם car c שווה new car, אין שום בעיה, garbage collector יוצר לי אותו בתוך ג'נרשן 0.
ואני רוצה עוד אובייקט ועוד אובייקט ועוד אובייקט, וכל אובייקט שאני יוצר, ה garbagecollector יוצר לי אותו רק בתוך אזור הזיכרון של ג'נרשן 0.
לצורך הדוגמא ציירתי את האובייקטים באותו הגודל, אבל כמובן שבמציאות כל אובייקט הוא בגודל אחר, יכול להיות. עכשיו, מה קורה כאשר ג'נרשן 0 התמלא לגמרי?
ביקשנו אובייקטים וביקשנו אובייקטים וביקשנו אובייקטים ואין לו יותר מקום בג'נריישן 0 כי הוא מילא אותו לגמרי באובייקטים וכעת אנחנו רוצים הוד אובייקט אז מה שהגארבץ' קולקטור עושה זה הוא צריך להעביר את האובייקטים הפעילים שלנו בלבד מג'נריישן 0 לג'נריישן 1 בכדי להמשיך ולהקצות לנו אובייקטים על גבי ג'נריישן 0
כל אובייקט שאנחנו יוצרים נוצר רק בג'נריישן 0. אם הוא מתמלא, אין בעיה, הגארבץ' קולקטור צריך להעביר את האובייקטים הפעילים לג'נריישן 1 בשביל לרוקן את ג'נריישן 0.
אבל מה זה אובייקט פעיל? האם אובייקט פעיל ואובייקט שאנחנו עובדים איתו? אז למעשה הגארבץ' קולקטור לא יכול לדעת מתי אנחנו הולכים לעבוד בעוד כמה דקות או בעוד כמה שעות עם איזשהו אובייקט שהגדרנו, ולכן ההגדרה של אובייקט פעיל ולא אובייקט שאנחנו עובדים איתו או לא עובדים איתו.
ההגדרה של אובייקט פעיל ואובייקט שיש לנו רפרנס אליו. זאת אומרת, יצרנו אותו, יש לנו את הכתובת שלו שמורה בתוך רפרנס, כזכור ה garbage collector מתעסק רק עם אובייקטים מסוג רפרנס טייפ, אז יכול להיות לנו רפרנס אליו,
ואנחנו יכולים להתעסק עם הרפרנס כי יש לנו אותו. זאת אומרת, אנחנו יכולים לגשת לאובייקט לפי שם הרפרנס ולעשות איתו פעולות.
אם איבדנו את הרפרנס לאובייקט, אז אין לנו שום יכולת בדוטנט לגשת לאובייקט הזה, ולכן מבחינת ה garbage collector אפשר לנקות אותו, אפשר להתעלם ממנו, הוא לא פעיל יותר.
בואו נראה דוגמה או שתיים לגבי איך אנחנו יכולים לעבד רפרנס לאובייקט. בואו נניח שיצרנו פה person p שווה new person. לאחר מכן עבדנו עם אובייקט הפרסון שלנו שהרפרנס שלו נקרא p ולאחר מכן שמנו בתוכו null.
זאת אומרת שדרסנו את הכתובת של האובייקט ב-null ואין לנו יותר אפשרות לגשת לאובייקט שנוצר על ידי new person. זאתי דוגמה אחת שבה אנחנו עיבדנו את הכתובת של האובייקט.
מבחינת ה garbage collector לפני השורה p=null לפני השורה הזאת הגארבג' קולקטור לא יכול להרוס לנו את האובייקט ולא יכול לגעת בו כי מבחינתו אנחנו יכולים לעבוד איתו.
לא בטוח שאנחנו באמת נעבוד איתו אבל מבחינת הגארבג' קולקטור אנחנו יכולים לעבוד איתו ולכן אסור לו לגעת באובייקט. אחרי השורה הזאת מבחינת הגארבג' קולקטור אין לנו שום יכולת לעבוד עם האובייקט ניו פרסון שיצרנו פה ולכן הוא נתון להריסה על ידי הגארבג' קולקטור.
דוגמה אחרת שיכולה להיות, זאת הדוגמה. יצרנו person p שווה new person, עבדנו איתו, ולאחר מכן רשמנו p שווה new person. נראה שיש לנו פה אובייקט אחד שנקרא p, אבל חדי עין יכולים להבין שיש לנו פה שני אובייקטים.
כל פעם שאתם משתמשים עם האופרטור new, אתם בעצם יוצרים אובייקט חדש. אז מה שקרה בדוגמה הזאת, אובייקט ראשון שנוצר בשורה הראשונה נכנס לכתובת בעלת רפרנס P, או ליתר דיוק יש לנו רפרנס P שקיבל את הכתובת שלו ולאחר מכן פשוט דרסנו את הכתובת של האובייקט הראשון בכתובת של אובייקט אחר.
מה קרה עם האובייקט הראשון? האובייקט הראשון חי לו באזור הזיכרון של ה-Generation 0 ואין לנו שום יכולת לגעת בו כי P עכשיו מצפיע על אובייקט אחר לגמרי.
אם אנחנו נשתמש עם P אנחנו נגיע לאובייקט האחר, לא לאובייקט הראשון. אז כאן איבדנו את הכתובת של האובייקט הראשון ומבחינת הגארבג' קולקטור הוא לא פעיל דוגמה אחרת יכולה להיות שיש לנו פה איזושהי פונקציה שעושה משהו בתוך הפונקציה רשמנו person p שווה new person עבדנו איתו וזהו
אבל בואו נחשוב רגע הרפרנס person p נמצא בתוך הפונקציה כמשתנה לוקאלי זאת אומרת הרפרנס p מוגדר בסטאק כאשר הפונקציה התחילה לפעול והוא נגיש רק על ידי הפונקציה כי הוא משתנה לוקאלי של הפונקציה האובייקט לעומת זאת נפתח באזור הזיכרון ג'נריישן אפס.
לכן אנחנו לא יכולים להשתמש עם האובייקט מחוץ לפונקציה. כאשר הפונקציה מסתיימת אנחנו יודעים שכל הזיכרון הלוקאלי של הפונקציה שנפתח ל-Stack סגמנט נהרס ואין לנו שום יכולת להשתמש איתו יותר.
לכן בסיום הפונקציה אין לנו יכולת לעבוד עם האובייקט שפתחנו פה New Person ומבחינת ה-Garbage Collector אין לנו שום רפרנס שמצביע עליו. כל הדוגמאות האלה כמובן תקפות, במידה ובמהלך העבודה עם האובייקט לא שמנו את הכתובת שלו ברפרנס אחר שעכשיו מצביע על האובייקט.
בהנחה שלא עשינו את זה, איבדנו בשלושת המקרים האלה את הכתובת לאובייקט ואין לנו שום יכולת להגיע אליו. אז מה הגארבץ' קולקטור עושה כאשר ג'נריישן 0 התמלאה לגמרי?
מה שהגארבץ' קולקטור עושה זה שתי פעולות. פעולה אחת נקראת מרק, וה garbage collector מסמן לעצמו אילו אובייקטים בכל התוכנית שלנו יש לנו רפרנס אליהם.
וכאן בדוגמה הזאת אנחנו רואים שיש שני אובייקטים כאלה. אנחנו יכולים לראות את האובייקט הזה מסומן ב-v ירוק, ואנחנו יכולים לראות את האובייקט הזה מסומן ב-v ירוק, וכל היתר אין לנו שום רפרנס אליהם.
אז זאת הפעולה הראשונה. אחרי שה garbage collector יודע אילו אובייקטים יש לנו רפרנס אליהם, זאת אומרת אנחנו רוצים לעבוד עם האובייקטים האלה או שאנחנו יכולים לעבוד איתם וכל היתר בכלל אין לנו שום סיכוי לעבוד איתם כי איבדנו את הרפרנס אליהם.
הגרמברידג' קולקטור עובר לפעולה השנייה והפעולה השנייה נקראת וייפ. והגרמברידג' קולקטור בפעולה הזאת מעט רק את האובייקטים שיש לנו רפרנס אליהם לג'נריישן הבא בתור מג'נריישן 0 הם מועתקים לג'נריישן 1. לכן מה יש לנו עכשיו בג'נריישן 0?
לג'נריישן 0 יש לנו או אובייקטים שאין לנו שום רפרנס אליהם ולכן אין לנו שום יכולת להשתמש בהם או אובייקטים שיש לנו רפרנס אליהם אבל כבר הם הועתקו לג'נריישן 1.
הערה חשובה בכל הסיפור הזה, כאשר הגארבץ' קולקטור נכנס לפעולה אז הוא עוצר את כל הטרדים בפרויקט שלנו.
למה? כי יכול להיות שאחת מהפקודות שלנו תתעסק עם איזשהו אובייקט שיש לנו רפרנס אליו והרי ישנה העתקה של האובייקט למקום אחר. אז קודם כל כל ה-threadים נעצרים, הדבר הבא שה-garbage collector עושה זה מבצע את ההעתקה, ומעדכן את ה-reference שלנו לאזור החדש שעכשיו האובייקט נמצא בו.
זאת אומרת שאם ה-reference הצביע פעם על האובייקט שקיים ב-generation 0, אחרי ההעתקה אותו רפרנס צריך להצביע על האובייקט שנמצא בג'נריישן 1. אחרי שהוא עושה את כל ההעתקה הזאתי הגארבץ' קולקטור מחזיר לפעולה את הטרדים.
כמו שאתם רואים פעילות גארבץ' קולקטור יכולה להיות פעילות שמאטה את התוכנית כי הוא פשוט עצר לנו את כל התוכנית. זאת הסיבה שהגארבץ' קולקטור לא נכנס לפעולה בכל פעם שאיבדנו רפרנס של אובייקט כי אם הוא היה עושה את זה התוכנית שלנו הייתה מאוד מאוד איטית.
ממש כמה מהיות השנייה, פתאום הגארבג' קולקטור היה צריך לעצור לנו את התוכנית ולהתחיל לעבוד. אז מה שהגארבג' קולקטור עושה, ורק כאשר ג'נרלשן אפס מתפלל לגמרי, הוא עושה את שתי הפעולות.
מרק מסמן איזה רפרנסים יש לנו, וייפ מעתיק אותם לג'נרלשן אפס, תוך כדי שתי הפעולות האלה עצר לנו את כל הטרדים, עדכן את הרפרנסים והחזיר את הפעילות.
עכשיו, מבחינת הגארבג' קולקטור, אפשר להמשיך להקצות אובייקטים חדשים על ג'נריישן 0.
הוא לא באמת מנקה ומרוקן את ג'נריישן 0, הוא פשוט יודע שהוא יכול להקצות עליו מההתחלה, ולכן מבחינתו ג'נריישן 0 נקי לגמרי. ואז, אם יש לנו פה אובייקט חדש שהגרבץ' קולקטור מבצע, הוא כמובן מתחיל להקצות אותו על ג'נריישן 0. ככה כל פעם ג'נריישן 0 מתמלא לגמרי, ורק האובייקטים שיש לנו רפרנס אליהם,
עוברים לג'נריישן 1. ג'נריישן 0 יכול מההתחלה לשמש בשביל הקצאת אובייקטים והוא מתמלא לגמרי וכל האובייקטים שיש לנו רפרנס אליהם מועתקים לג'נריישן 1 על ידי הגארבג' קולקטור.
אבל מה קורה כאשר ג'נריישן 1 כבר התמלה לגמרי וכמובן גם ג'נריישן 0 התמלה לגמרי? אין לנו יותר מקום להקצות בג'נריישן 0 וגם אין לנו יותר מקום להקצות בג'נריישן 1. מה עכשיו קורה?
ניחשתם נכון? כל הפעילות הזאת מתרחשת שוב פעם עבור העברת אובייקטים מג'נריישן 1 לג'נריישן 2. אז גם כאן הגארבץ' קולקטור שוב פעם מבצע את שתי הפעולות.
פעולה ראשונה הוא עושה מרק ומסמן את כל האובייקטים שיש לנו רפרנס אליהם ושהיו בג'נריישן 1. כאן בסרטוט אנחנו רואים שהוא מצא ארבעה אובייקטים כאלה אז הגארבץ' קולקטור יכול עכשיו להעתיק רק את ארבעת האובייקטים האלה מג'נריישן 1 לג'נריישן 2.
הנה אנחנו רואים שהם הועתקו מבחינת הגארבץ' קולקטור כל ג'נריישן 1 נתון להקצה מחדש מפני שאו שיש בו אובייקטים שאיבדנו את הרפרנס שלהם ואז גם ככה אנחנו לא יכולים להשתמש בהם או שיש לו אובייקטים שיש לנו רפרנס אליהם אבל כבר הם נמצאים במקום החדש לכן מבחינת הגארבץ' קולקטור ג'נריישן 1 נקי ואז הגארבץ' קולקטור מבצע את אותה פעולה על ג'נריישן 0 מבצע מרק
ואנחנו רואים שיש לנו פה שני אובייקטים אחרים כרגע שהוא מצא שיש לנו רפרנס אליהם ווייפ מעביר אותם לג'נריישן 1 תמיד 0 עובר ל-1, 1 עובר ל-2 ואז מבחינת הגארבץ' קולקטור גם ג'נריישן 0 יכול להיות מוקצה מחדש ולהקצות אובייקטים מחדש על ג'נריישן 0. אז ג'נריישן 0 מתמלא מעבירים את האובייקטים
הפעילים לג'נריישן 1, ג'נריישן 1 מתמלא מעבירים את האובייקטים הפעילים לג'נריישן 2, ג'נריישן 2 מתמלא מבצעים מעין די פרגמנט על עצמו ומעתיקים את האובייקטים שיש לנו רפרנס להתחלה שלהם, אם ג'נריישן 2 מתמלא לגמרי לגמרי לגמרי וואלה אין יותר זיכרון ביי ביי אקספשן אאוט אוף ממרי אקספשן.
אז כאן ראינו איך הגארבג' קולקטור עובד פנימית וכעת אנחנו יכולים לעבור לכמה דוגמאות בשביל להמחיש את זה. בואו נבנה איזושהי מחלקה נקרא לה טסט אין בה כלום.
כעת אנחנו הולכים ליצור אובייקט טסט שווה ניו טסט אוקיי בדיוק איפה שאני נמצא כרגע יש לי רפרנס למחלקה טסט אז אם יש לי רפרנס לאובייקט ליתר דיוק שיצרתי פה אובייקט החדש הגארבוץ' קולקטור לא ייגע בו אז איך קודם כל אנחנו יודעים בכלל שהגארבוץ' קולקטור נכנס לפעולה דבר ראשון
במחלקה אנחנו יכולים ליצור קונסטרקטור בואו נרשום פה איזושהי הודעה שאני בטסט סוגריים מרובעים אבל במחלקה אנחנו אנחנו יכולים ליצור גם משהו שנקרא דיסטרקטור.
דיסטרקטור זאת פונקציה שמופעלת אוטומטית על ידי הגארבג' קולקטור, אנחנו לא יכולים לקרוא לה בעצמנו, בזמן שהגארבג' קולקטור משחרר את המשאבים של האובייקט.
הדיסטרקטור נבנה על ידי סימן הטילדה ושם הקלאס. אי אפשר להעמיס דיסטרקטור, אין לו הרשאה דגישה, אין לו מידע שמתקבל, הוא לא יכול להיות סטטי כלומר אנחנו יכולים לבנות דיסטרקטור אך ורק בצורה כזאת.
למעשה המילה דיסטרקטור מגיעה משפות עתיקות יותר כמו c++, בדוטנט נהוג לקרוא לזה פיינלייזר ולא דיסטרקטור אבל הרבה קוראים לזה דיסטרקטור.
כאן אני רוצה ליצור או להציג איזושהי מחרוזת שאומרת שאני כרגע בדיסטרקטור. אוקיי אז אם אנחנו עכשיו נריץ את זה ממש את התוכנית כמו שהיא אנחנו הולכים לראות שיש כמובן קונסטרקטור מתבצע, תמיד כשאובייקט נוצר יש קונסטרקטור, אבל אנחנו רואים גם דיסטרקטור.
זאת אומרת, מה שקרה כאן זה שה garbage collector שחרר את הזיכרון של האובייקט, אבל אין לי פה כל כך זיכרון מבוזבז למה ה garbagecollector שחרר את האובייקט הזה, הרי התוכנית לא זוללת כל כך הרבה זיכרון ש-generation 0 התמלא לגמרי.
אז הגרבץ' קולקטור למעשה מופעל במספר מקרים. מקרה ראשון, כאשר נגמר הזיכרון בג'נרשן 0 והוא צריך להיות מופעל בשביל להעביר את האובייקטים הפעילים לג'נרשן 1. מקרה שני, כאשר ג'נרשן 1 התמלא ואז הגרבץ' קולקטור צריך להעביר את האובייקטים הפעילים מג'נרשן 1 לג'נרשן 2 והוא עושה את זה גם מג'נרשן 0 לג'נרשן 1. מקרה שלישי זה
כאשר ג'נרשן 2 התמלא לגמרי ואז הוא מבצע מעין דיפרגמנט על עצמו, מייצם את הזיכרון על עצמו, מעביר את 1 ל-2, מעביר את 0 ל-1.
מקרה רביעי זה סוף התוכנית. בסוף התוכנית הגארבץ' קולקטור אוטומטית מופעל בשביל לשחרר את כל הזיכרון של התוכנית. ויש מקרה חמישי שזאת תהיה קריאה יזומה.
ישנה מחלקה שנקראת gc והיא אחראית על הגארבץ' קולקטור. כאשר אתם רושמים gc.collect אתם בעצם אומרים לגארבץ' קולקטור בוא בבקשה תעבוד קולקט יכולה לקבל את הג'נריישן שאתם רוצים שהגארבץ' קולקטור יתייחס אליו אם נתתם קולקט 0 אמרתם לגארבץ' קולקטור בוא תנקה רק את ג'נריישן 0 ותעביר אותו לג'נריישן
1 בלי קשר אם ג'נריישן 0 מלא או לא גם אם ג'נריישן 0 לא מלא בכלל ואמרתם קולקט 0 הגארבץ' קולקטור ינקה את 0 יעביר את האובייקטים הפעילים מ-0 ל-1. אם אמרתם קולקט 1, הגארבץ' קולקטור יעביר את 1 ל-2 ואת 0 ל-1.
אם אמרתם קולקט 2, הגארבץ' קולקטור מבצע את שלושת הג'נריישנים, מנקה את 2 על עצמו, 1 מעביר ל-2, 0 מעביר ל-1,