ריבוי עיבודים ניתן להשוות לריבוי הליכים. עם זאת, זה מבדיל בכך שאנו יכולים לבצע רק שרשור אחד בכל רגע בגלל ה-GIL שמשתמשים בהשרשור. ריבוי עיבודים הוא תהליך של ביצוע פעולות ברצף על פני מספר ליבות מעבד. לא ניתן להפעיל חוטים במקביל. עם זאת, ריבוי עיבודים מאפשר לנו לבסס את התהליכים ולהפעיל אותם במקביל על ליבות CPU שונות. הלולאה, כגון for-loop, היא אחת משפות הסקריפט הנפוצות ביותר. חזור על אותה עבודה תוך שימוש בנתונים שונים עד שמגיעים לקריטריון, כגון מספר קבוע מראש של איטרציות. הלולאה משיגה כל איטרציה בזה אחר זה.
דוגמה 1: שימוש ב-For-Loop במודול Python Multiprocessing
בדוגמה זו, אנו משתמשים בתהליך for-loop ובתהליך המחלקה של מודול ריבוי עיבוד Python. אנו מתחילים בדוגמה פשוטה מאוד כדי שתוכלו להבין במהירות כיצד פועל ה-Python multiprocessing for-loop. באמצעות ממשק הדומה למודול השרשור, ריבוי העיבודים אורז את יצירת התהליכים.
על ידי שימוש בתתי-תהליכים ולא בשרשורים, חבילת ריבוי העיבודים מספקת במקביל גם מקומית וגם מרוחקת, ובכך נמנעת מנעול המתורגמן הגלובלי. השתמש בלולאה for, שיכולה להיות אובייקט מחרוזת או טופלה, כדי לחזור על רצף ללא הרף. זה מתפקד פחות כמו מילת המפתח הנראית בשפות תכנות אחרות ויותר כמו שיטת איטרטור שנמצאת בשפות תכנות אחרות. על ידי התחלת ריבוי עיבוד חדש, אתה יכול להריץ לולאת for-המבצעת פרוצדורה במקביל.
נתחיל ביישום הקוד לביצוע קוד על ידי שימוש בכלי 'ספיידר'. אנו מאמינים ש'ספיידר' הוא גם הטוב ביותר להפעלת Python. אנו מייבאים תהליך מודול ריבוי עיבודים שהקוד פועל. ריבוי עיבודים בקונספט של Python המכונה 'מחלקת תהליכים' יוצר תהליך Python חדש, נותן לו שיטה לביצוע קוד, ונותן ליישום האב דרך לנהל את הביצוע. המחלקה Process מכילה את ההליכים start() ו-join(), ששניהם חיוניים.
לאחר מכן, אנו מגדירים פונקציה מוגדרת על ידי משתמש בשם 'func'. מכיוון שזו פונקציה המוגדרת על ידי משתמש, אנו נותנים לה שם לבחירתנו. בתוך הגוף של פונקציה זו, אנו מעבירים את המשתנה 'נושא' כארגומנט ואת הערך 'מתמטיקה'. לאחר מכן, אנו קוראים לפונקציה 'print()', ומעבירים את ההצהרה 'שם הנושא הנפוץ הוא' וכן ארגומנט ה'נושא' שלו שמכיל את הערך. לאחר מכן, בשלב הבא, אנו משתמשים ב-'if name== _main_', אשר מונע ממך להפעיל את הקוד כאשר הקובץ מיובא כמודול ומאפשר לך לעשות זאת רק כאשר התוכן מבוצע כסקריפט.
בחלק התנאים שאתה מתחיל איתו אפשר לחשוב ברוב הנסיבות כמיקום לספק את התוכן שאמור להתבצע רק כאשר הקובץ שלך פועל כסקריפט. לאחר מכן, אנו משתמשים בנושא הטיעון ומאחסנים בו כמה ערכים שהם 'מדע', 'אנגלית' ו'מחשב'. לאחר מכן, התהליך מקבל את השם 'process1[]' בשלב הבא. לאחר מכן, אנו משתמשים ב-'process(target=func)' כדי לקרוא לפונקציה בתהליך. המטרה משמשת לקריאת הפונקציה, ואנו שומרים תהליך זה במשתנה 'P'.
לאחר מכן, אנו משתמשים ב- 'process1' כדי לקרוא לפונקציה 'append()' אשר מוסיפה פריט לסוף הרשימה שיש לנו בפונקציה 'func'. מכיוון שהתהליך מאוחסן במשתנה 'P', אנו מעבירים את 'P' לפונקציה זו כארגומנט שלה. לבסוף, אנו משתמשים בפונקציה 'start()' עם 'P' כדי להתחיל את התהליך. לאחר מכן, אנו מריצים את השיטה שוב תוך כדי אספקת הארגומנט 'נושא' ומשתמשים ב-'for' בנושא. לאחר מכן, באמצעות 'process1' ושיטת 'add()' פעם נוספת, אנו מתחילים את התהליך. לאחר מכן התהליך פועל והפלט מוחזר. לאחר מכן נאמר להליך להסתיים באמצעות טכניקת 'join()'. התהליכים שאינם קוראים להליך 'join()' לא ייצאו. נקודה חיונית אחת היא שיש להשתמש בפרמטר מילת המפתח 'args' אם ברצונך לספק טיעונים כלשהם במהלך התהליך.
כעת, אתה יכול לראות בפלט שהמשפט מוצג תחילה על ידי העברת הערך של הנושא 'מתמטיקה' אותו אנו מעבירים לפונקציה 'func' מכיוון שאנו קוראים לזה תחילה באמצעות הפונקציה 'process'. לאחר מכן, אנו משתמשים בפקודה 'append()' כדי לקבל ערכים שכבר היו ברשימה שמתווספת בסוף. לאחר מכן הוצגו 'מדע', 'מחשב' ו'אנגלית'. אבל, כפי שאתה יכול לראות, הערכים אינם ברצף הנכון. הסיבה לכך היא שהם עושים זאת ברגע שההליך מסתיים ומדווחים על הודעתם.
דוגמה 2: המרה של For-Loop ברצף ל- Multiprocessing Parallel For-Loop
בדוגמה זו, משימת לולאת ריבוי עיבוד מבוצעת ברצף לפני ההמרה למשימת לולאה מקבילה. אתה יכול לעבור בין רצפים כמו אוסף או מחרוזת בסדר שהם מתרחשים באמצעות for-loops.
עכשיו, בואו נתחיל ליישם את הקוד. ראשית, אנו מייבאים 'שינה' ממודול הזמן. באמצעות הליך 'sleep()' במודול הזמן, אתה יכול להשעות את ביצוע השרשור הקורא כל זמן שתרצה. לאחר מכן, אנו משתמשים ב'אקראי' מהמודול האקראי, מגדירים פונקציה עם השם 'func', ומעבירים את מילת המפתח 'argu'. לאחר מכן, אנו יוצרים ערך אקראי באמצעות 'val' ומגדירים אותו ל'אקראי'. לאחר מכן, אנו חוסמים לתקופה קטנה באמצעות שיטת 'sleep()' ומעבירים את 'val' כפרמטר. לאחר מכן, כדי לשדר הודעה, אנו מפעילים את שיטת 'print()', מעבירים את המילים 'ready' ואת מילת המפתח 'arg' כפרמטר שלה, כמו גם 'created' ומעבירים את הערך באמצעות 'val'.
לבסוף, אנו משתמשים ב-'שטיפה' ומגדירים אותו ל-'True'. המשתמש יכול להחליט אם לחצץ את הפלט או לא באמצעות אפשרות השטיפה בפונקציית ההדפסה של Python. ערך ברירת המחדל של פרמטר זה הוא False מציין שהפלט לא יאוחסן. הפלט מוצג כסדרה של קווים העוקבים זה אחר זה אם מגדירים אותו כ-true. לאחר מכן, אנו משתמשים ב-'if name== main' כדי לאבטח את נקודות הכניסה. לאחר מכן, אנו מבצעים את העבודה ברצף. כאן, הגדרנו את הטווח ל-'10', כלומר הלולאה מסתיימת לאחר 10 איטרציות. לאחר מכן, אנו קוראים לפונקציה 'print()', מעבירים לה את משפט הקלט 'ready' ומשתמשים באפשרות 'flush=True'.
כעת אתה יכול לראות שכאשר אנו מבצעים את הקוד, הלולאה גורמת לפונקציה לפעול '10' פעמים. זה חוזר על פני 10 פעמים, מתחיל במדד אפס ומסתיים במדד תשע. כל הודעה מכילה מספר משימה שהוא מספר פונקציה שאנו מעבירים בתור 'arg' ומספר יצירה.
לולאה רציפה זו הופכת כעת ללולאה מקבילה מרובת עיבודים. אנחנו משתמשים באותו קוד, אבל אנחנו הולכים לכמה ספריות ופונקציות נוספות עבור ריבוי עיבודים. לכן, עלינו לייבא את התהליך מ-multiprocessing, בדיוק כפי שהסברנו קודם. לאחר מכן, אנו יוצרים פונקציה בשם 'func' ומעבירים את מילת המפתח 'arg' לפני השימוש ב-'val=random' כדי לקבל מספר אקראי.
לאחר מכן, לאחר הפעלת שיטת 'print()' כדי להציג הודעה ומתן פרמטר 'val' כדי לעכב מעט תקופה, אנו משתמשים בפונקציה 'if name= main' כדי לאבטח את נקודות הכניסה. לאחר מכן, אנו יוצרים תהליך וקוראים לפונקציה בתהליך באמצעות 'process' ומעבירים את ה-'target=func'. לאחר מכן, אנו מעבירים את ה- 'func', 'arg', מעבירים את הערך 'm', ומעבירים את הטווח '10', כלומר הלולאה מסיימת את הפונקציה לאחר איטרציות '10'. לאחר מכן, אנו מתחילים את התהליך באמצעות שיטת 'start()' עם 'process'. לאחר מכן, אנו קוראים לשיטת 'join()' כדי להמתין לביצוע התהליך וכדי להשלים את כל התהליך לאחר מכן.
לכן, כאשר אנו מבצעים את הקוד, הפונקציות מתקשרות לתהליך הראשי ומתחילות בביצוען. עם זאת, הם נעשים עד להשלמת כל המשימות. אנו יכולים לראות זאת מכיוון שכל משימה מתבצעת במקביל. הוא מדווח על ההודעה שלו ברגע שהיא מסתיימת. המשמעות היא שלמרות שההודעות אינן תקינות, הלולאה מסתיימת לאחר השלמת כל '10' האיטרציות.
סיכום
כיסינו את ה-Python multiprocessing for-loop במאמר זה. הצגנו גם שני איורים. האיור הראשון מראה כיצד להשתמש ב-for-loop בספריית ריבוי עיבוד הלולאה של Python. והאיור השני מראה כיצד לשנות לולאה רציפה ללולאה מרובת עיבוד מקבילה. לפני בניית הסקריפט עבור Python multiprocessing, עלינו לייבא את מודול ריבוי העיבוד.