מבוא ל-Currency in Go

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

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

מקבילות בגו

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

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

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

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

כיצד להשתמש בגורוטינים לביצוע קוד במקביל

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

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

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

funcרָאשִׁי() {
ללכת function1() // צור והפעל goroutine עבור function1
ללכת function2() // צור והפעל goroutine עבור function2
// ...
}
funcפונקציה 1() {
// קוד עבור function1
}
funcפונקציה2() {
// קוד עבור function2
}

כאשר התוכנית מפעילה function1() ו function2() עם ה ללכת מילת המפתח, זמן הריצה Go מבצע את הפונקציות במקביל כ-goroutines.

הנה דוגמה לשימוש ב-goroutine שמדפיס טקסט לקונסולה:

חֲבִילָה רָאשִׁי
יְבוּא (
"fmt"
"זְמַן"
)
funcprintText() {
ל אני := 1; אני <= 5; i++ {
 fmt. Println("הדפסת טקסט", אני)
 זְמַן. לִישׁוֹן(1 *זמן. שְׁנִיָה)
 }
}
funcרָאשִׁי() {
ללכת printText() // התחל גורוטינה כדי להפעיל את הפונקציה printText במקביל
// בצע משימות אחרות בגורוטינה הראשית
ל אני := 1; אני <= 5; i++ {
 fmt. Println("ביצוע משימות אחרות", אני)
 זְמַן. לִישׁוֹן(500 *זמן. אלפיות השנייה)
 }
// המתן עד שהגוראוטינה תסתיים
 זְמַן. לִישׁוֹן(6 *זמן. שְׁנִיָה)
}

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

ה רָאשִׁי הפונקציה מתחילה גורוטינה על ידי קריאה לך printText, אשר משיקה את printText לתפקד כגורוטין בו-זמני נפרד המאפשר לפונקציה לפעול במקביל לשאר הקוד ב- רָאשִׁי פוּנקצִיָה.

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

שימוש בערוצים לתקשורת וסנכרון

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

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

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

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

funcרָאשִׁי() {
// צור ערוץ לא מאוחסן מסוג מחרוזת
 ch := עשה(צ'אןחוּט)
// Goroutine 1: שולח הודעה לערוץ
ללכתfunc() {
 צ' "שלום ערוץ!"
 }()
// Goroutine 2: מקבל את ההודעה מהערוץ
 msg :=  fmt. Println (msg) // פלט: שלום, ערוץ!
}

הערוץ ב רָאשִׁי הפונקציה היא ערוץ לא מאגר בשם ch נוצר עם ה עשה() פוּנקצִיָה. הגורוטין הראשון שולח את ההודעה "שלום ערוץ!" לתוך הערוץ באמצעות מפעיל, והגוראוטינה השנייה מקבלת את ההודעה מהערוץ באמצעות אותו מפעיל. סוף - סוף, ה רָאשִׁי הפונקציה מדפיסה את ההודעה שהתקבלה לקונסולה.

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

funcרָאשִׁי() {
// ערוץ לא מבוצר
 ch1 := עשה(צ'אןint)
// ערוץ מופר עם קיבולת של 3
 ch2 := עשה(צ'אןחוּט, 3)
// שליחת וקבלת ערכים מערוצים
 ch1 42// שלח ערך לתוך ch1
 value1 := // קבל ערך מ-ch1
 ch2 "שלום"// שלח ערך לתוך ch2
 value2 := // קבל ערך מ-ch2
}

ה רָאשִׁי הפונקציה יוצרת שני ערוצים: ch1 הוא ערוץ מספרים שלמים לא מפוצץ, בעוד ch2 הוא ערוץ מחרוזת מאגר עם קיבולת של 3. אתה יכול לשלוח ולקבל ערכים לערוצים אלה וממנו באמצעות ה אופרטור (הערכים חייבים להיות מהסוג שצוין).

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

funcרָאשִׁי() {
 ch := עשה(צ'אןbool)
ללכתfunc() {
 fmt. Println("גורוטינה 1")
 צ' נָכוֹן// השלמת אות
 }()
ללכתfunc() {
 // המתן לאות ההשלמה מ- Goroutine 1
 fmt. Println("גורוטין 2")
 }()
 // המתן לאות השלמה מ- Goroutine 2
 fmt. Println("גורוטינה ראשית")
}

ה ch הערוץ הוא בוליאני. שני גורוטינים רצים במקביל ב- רָאשִׁי פוּנקצִיָה. Goroutine 1 מסמן את השלמתו על ידי שליחת א נָכוֹן ערך לתוך הערוץ ch. Goroutine 2 מחכה לאות ההשלמה על ידי קבלת ערך מהערוץ. לבסוף, הגורוטין הראשי מחכה לאות ההשלמה מגורוטין שני.

אתה יכול לבנות אפליקציות אינטרנט ב-Go With Gin

אתה יכול לבנות אפליקציות אינטרנט בעלות ביצועים גבוהים ב-Go עם Gin תוך מינוף תכונות המקלות של Go.

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