מהי ריתוך משנה בפייתון וכיצד להשיג זאת?

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

הנה סיכום מהיר של כל המגמות המכוסות במאמר זה:

מה ההבדל בין hashap לבין hashable

מה זה ריבוי משימות בפייתון?
מהו חוט?
מהי ריבוי הליכי משנה בפייתון?
מתי להשתמש ב multithreading בפייתון?
כיצד להשיג Multithreading בפייתון?
כיצד ליצור פתילים בפייתון?

• בלי ליצור כיתה
• על ידי הרחבת מעמד החוטים
• מבלי להאריך את מעמד החוטים

יתרונות השימוש בריבוי הליכי משנה בפייתון

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

מהי ריבוי משימות בפייתון?

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

ישנם שני סוגים של ריבוי משימות במערכת הפעלה:

• מבוסס על תהליכים
• מבוסס חוט

במאמר זה תלמד על מבוסס חוט ריבוי משימות או ריבוי השחלות .

מהו חוט?

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

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

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

מתי להשתמש ב- Multithreading בפייתון?

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

לכן ניתן להשתמש ברב-הליכי רק כאשר התלות בין שרשורים בודדים אינה קיימת.

מאמר זה מראה עוד כיצד ניתן להשיג Multithreading ב- Python.

כיצד להשיג Multithreading בפייתון?

ניתן להשיג הליכי ריבוי ב- Python על ידי ייבוא ​​ה- הַשׁחָלָה מודול.

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

conda להתקין -c conda-forge tbb

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

ייבוא ​​השחלה משרשור ייבוא ​​*

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

כיצד ליצור פתילים בפייתון?

ניתן ליצור חוטים בפייתון בשלוש דרכים:

1. בלי ליצור כיתה
2. על ידי הרחבת מעמד החוט
3. מבלי להאריך את שיעור החוטים

בלי ליצור כיתה

ניתן לבצע הליכי ריבוי ב- Python מבלי ליצור גם מחלקה. הנה דוגמה להדגמת אותו הדבר:

דוגמא:

משרשור ייבוא ​​* הדפס (current_thread (). getName ()) def mt (): הדפס ('חוט ילד') child = חוט (target = mt) child.start () הדפס ('ביצוע שם חוט:', current_thread ( ) .getName ())

תְפוּקָה:

חוט ילד MainThread מבצע שם חוט: MainThread

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

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

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

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

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

דוגמא:

ייבוש השחלה ייבוא ​​כיתת זמן מיתוס (threading.Thread): def run (עצמי): עבור x בטווח (7): הדפס ('שלום מילד') a = mythread () a.start () a.join () הדפס ('ביי מ-', current_thread (). GetName ())

תְפוּקָה:
היי מילד
היי מילד
היי מילד
היי מילד
היי מילד
היי מילד
היי מילד
להתראות מ- MainThread

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

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

מבלי להאריך את שיעור החוטים

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

משרשור ייבוא ​​* מחלקה ex: def myfunc (עצמי): # עצמאי הכרחי כפרמטר ראשון בכיתת func עבור x בטווח (7): הדפס ('ילד') myobj = ex () thread1 = Thread (target = myobj. myfunc) thread1.start () thread1.join () הדפס ('נעשה')

תְפוּקָה:

יֶלֶד
יֶלֶד
יֶלֶד
יֶלֶד
יֶלֶד
יֶלֶד
יֶלֶד
בוצע

יתרונות השימוש בהברגה

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

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

להלן דוגמה לבדיקת משך הזמן שלוקח קוד לביצוע עם ובלי ריבוי השחלות בפייתון:

 דוגמא: 

זמן ייבוא ​​def sqr (n): עבור x ב- n: time.sleep (1) x% 2 קוביית def (n): עבור x ב- n: time.sleep (1) x% 3 n = [1,2,3 , 4,5,6,7,8] s = time.time () sqr (n) קוביה (n) e = time.time () הדפס (ים)

תְפוּקָה:

16.042309284210205

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

דוגמא:

ייבוא ​​השחלה משרשור ייבוא ​​* זמן יבוא def sqr (n): עבור x ב- n: time.sleep (1) הדפס ('שארית לאחר חלוקה ב- 2', x% 2) קוביית def (n): עבור x ב- n: time.sleep (1) הדפס ('שארית לאחר חלוקה ב- 3', x% 3) n = [1,2,3,4,5,6,7,8] התחלה = time.time () t1 = חוט ( target = sqr, args = (n,)) t2 = Thread (target = cube, args = (n,)) t1.start () time.sleep (1) t2.start () t1.join () t2.join () סוף = זמן.זמן () הדפסה (סוף התחלה)

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

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

יש לך שאלה עבורנו? אנא הזכיר זאת בקטע ההערות בבלוג 'רב-הברגה בפייתון' ואנחנו רָצוֹן תחזור אליך בהקדם האפשרי.

פיבונאצי c ++ רקורסיבי

כדי לקבל ידע מעמיק על Python יחד עם היישומים השונים שלו, אתה יכול להירשם לשידור חי עם תמיכה 24/7 וגישה לכל החיים.