איסוף אשפה ב-Go

חלק מהיחידה תכנות מונחה עצמים במסלול ה-GO של Coddy. שיעור 23 מתוך 107.

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

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

func createPerson() *Person {
    p := &Person{Name: "Alice", Age: 30}
    return p  // p מועבר לערימה, GC ינהל אותו
}

func main() {
    person := createPerson()
    fmt.Println(person.Name)
    // כאשר כבר לא משתמשים ב-person, GC משחרר את הזיכרון
}

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

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

אתגר

קל

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

תארגנו את הקוד שלכם בשני קבצים:

session.go: הגדירו מבנה Session עם השדות ID (מחרוזת), Username (מחרוזת) ו-Data (מערך של מחרוזות). צרו פונקציה NewSession שמקבלת מזהה ושם משתמש, מקצה Session חדש בערימה (על ידי החזרת מצביע) ומאתחלת את מערך ה-Data כריק. הוסיפו גם מתודה AddData עם מקבל מסוג מצביע, שמוסיפה מחרוזת למערך ה-Data של ההפעלה, ומתודה Summary שמחזירה מחרוזת מעוצבת המציגה את פרטי ההפעלה.
main.go: קראו את פרטי ההפעלה מהקלט, צרו הפעלה באמצעות פונקציית הבנאי שלכם, הוסיפו לה כמה רשומות נתונים והציגו את סיכום ההפעלה. מכיוון שההפעלה נוצרת בתוך פונקציה ומוחזרת כמצביע, היא בורחת לערימה, שם אוסף האשפה ינהל אותה.

הקלטים הבאים יסופקו:

שורה 1: מזהה ההפעלה
שורה 2: שם המשתמש
שורה 3: רשומת הנתונים הראשונה להוספה
שורה 4: רשומת הנתונים השנייה להוספה

המתודה Summary שלכם צריכה להחזיר מחרוזת בפורמט הבא:

Session [ID] for user [Username]
Data entries: [count]
- [entry1]
- [entry2]

לדוגמה, עבור sess-001, alice, login ו-view_dashboard, הפלט שלכם צריך להיות:

Session sess-001 for user alice
Data entries: 2
- login
- view_dashboard

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

נסו בעצמכם

package main

import (
	"bufio"
	"fmt"
	"os"
)

func main() {
	reader := bufio.NewReader(os.Stdin)

	// קרא את מזהה ההפעלה
	sessionID, _ := reader.ReadString('\n')
	sessionID = sessionID[:len(sessionID)-1]

	// קרא את שם המשתמש
	username, _ := reader.ReadString('\n')
	username = username[:len(username)-1]

	// קרא את רשומת הנתונים הראשונה
	data1, _ := reader.ReadString('\n')
	data1 = data1[:len(data1)-1]

	// קרא את רשומת הנתונים השנייה
	data2, _ := reader.ReadString('\n')
	data2 = data2[:len(data2)-1]

	// TODO: צור הפעלה חדשה באמצעות הפונקציה NewSession
	// ההפעלה תועבר לערימה מכיוון שאנו מחזירים מצביע

	// TODO: הוסף את רשומות הנתונים להפעלה באמצעות המתודה AddData

	// TODO: הדפס את סיכום ההפעלה באמצעות המתודה Summary
	fmt.Println("")
}