המרכיב המכריע ביותר במבנה הנתונים הוא התור. תור מבנה הנתונים 'נכנס ראשון, יוצא ראשון' שהוא הבסיס לריבוי עיבודים של Python ניתן להשוואה. תורים מסופקים לפונקציית התהליך כדי לאפשר לתהליך לאסוף את הנתונים. פריט הנתונים הראשון שיימחק מהתור הוא הפריט הראשון שיש להזין. אנו משתמשים בשיטת 'put()' של התור כדי להוסיף את הנתונים לתור ובשיטת ה-'get()' שלו כדי לאחזר את הנתונים מהתור.
דוגמה 1: שימוש בשיטת Queue() ליצירת תור ריבוי עיבוד ב-Python
בדוגמה זו, אנו יוצרים תור ריבוי עיבודים ב- Python באמצעות שיטת 'queue()'. ריבוי עיבודים מתייחס לשימוש במעבד אחד או יותר במערכת לביצוע שני תהליכים או יותר בו זמנית. Multiprocessing, מודול בנוי ב- Python, מאפשר מעבר בין תהליכים. עלינו להכיר את מאפיין התהליך לפני עבודה עם ריבוי עיבודים. אנו מודעים לכך שהתור הוא מרכיב מכריע במודל הנתונים. תור הנתונים הסטנדרטי, אשר בנוי על רעיון 'ראשון-נכנס-ראשון-יוצא', ו-Python multiprocessing הם מקבילים מדויקים. באופן כללי, התור מאחסן את אובייקט Python והוא חיוני להעברת נתונים בין משימות.
הכלי 'ספיידר' משמש ליישום הסקריפט של Python שקיים, אז בואו פשוט נתחיל. עלינו לייבא תחילה את מודול ריבוי העיבודים מכיוון שאנו מריצים את סקריפט ריבוי העיבודים של Python. עשינו זאת על ידי ייבוא מודול ריבוי העיבודים בתור 'm'. באמצעות טכניקת 'm.queue()', אנו מפעילים את שיטת ה-'queue()' של ריבוי עיבודים. כאן, אנו יוצרים משתנה שנקרא 'תור' וממקמים בו את שיטת ה-multiprocessing 'queue()'. מכיוון שאנו יודעים שהתור מאחסן פריטים בסדר 'נכנס ראשון, יוצא ראשון', הפריט שנוסיף ראשון מוסר ראשון. לאחר השקת תור ריבוי העיבודים, אנו קוראים לשיטת 'print()', ומעבירים את ההצהרה 'יש תור ריבוי עיבודים' בתור הארגומנט שלה להציג אותו על המסך. לאחר מכן, מכיוון שאנו מאחסנים את התור שנבנה במשתנה זה, אנו מדפיסים את התור על ידי העברת המשתנה 'תור' בסוגריים של שיטת 'print()'.
התמונה הבאה מראה שתור ריבוי העיבודים של Python נבנה כעת. הצהרת ההדפסה מוצגת תחילה. לאחר שתור ריבוי עיבוד זה נבנה בכתובת הזיכרון המיועדת, ניתן להשתמש בו כדי להעביר את הנתונים הנבדלים בין שני תהליכים רצים או יותר.
דוגמה 2: שימוש בשיטת 'Qsize()' כדי לקבוע את הגודל של תור ריבוי העיבודים ב-Python
אנחנו קובעים את גודל התור של ריבוי עיבודים במקרה זה. כדי לחשב את גודל התור של ריבוי עיבודים, אנו משתמשים בשיטת 'qsize()'. הפונקציה 'qsize()' מחזירה את הגודל האמיתי של תור ריבוי העיבודים של Python. במילים אחרות, שיטה זו מספקת את המספר הכולל של פריטים בתור.
נתחיל בייבוא מודול ריבוי העיבוד של Python בתור 'm' לפני הפעלת הקוד. לאחר מכן, באמצעות הפקודה 'm.queue()', אנו מפעילים את פונקציית multiprocessing 'queue()' ומכניסים את התוצאה למשתנה 'Queue'. לאחר מכן, באמצעות שיטת 'put()', אנו מוסיפים את הפריטים לתור בשורה הבאה. שיטה זו משמשת להוספת הנתונים לתור. לכן, אנו קוראים ל-'Queue' בשיטת 'put()' ומספקים את המספרים השלמים כאלמנט שלו בסוגריים שלו. המספרים שאנו מוסיפים הם '1', '2', '3', '4', '5', '6' ו- '7' באמצעות הפונקציות 'put()'.
יתר על כן, באמצעות 'תור' כדי לקבל את גודל התור של ריבוי עיבודים, אנו קוראים ל-'qsize()' עם תור ריבוי העיבודים. לאחר מכן, במשתנה 'result' החדש שנוצר, אנו שומרים את התוצאה של שיטת 'qsize()'. לאחר מכן, אנו קוראים לשיטת 'print()' ומעבירים את ההצהרה 'גודל התור הרב-עיבוד הוא' כפרמטר שלה. לאחר מכן, אנו קוראים למשתנה 'result' בפונקציה 'print()' מכיוון שהגודל נשמר במשתנה זה.
לתמונת הפלט יש את הגודל המוצג. כאשר אנו משתמשים בפונקציה 'put()' כדי להוסיף שבעה אלמנטים לתור ריבוי עיבודים ובפונקציה 'qsize()' כדי לקבוע את הגודל, גודל תור ריבוי העיבודים '7' מוצג. הצהרת הקלט 'גודל התור של ריבוי עיבודים' מוצגת לפני הגודל.
דוגמה 3: שימוש בשיטת 'Put()' ו-'Get()' בתור ריבוי עיבודים של Python
שיטות התור 'put()' ו-'get()' מתור ריבוי העיבודים של Python משמשות בדוגמה זו. אנו מפתחים שתי פונקציות מוגדרות על ידי משתמש בדוגמה זו. בדוגמה זו, אנו מגדירים פונקציה ליצירת תהליך המייצר '5' מספרים שלמים אקראיים. אנו משתמשים גם בשיטת 'put()' כדי להוסיף אותם לתור. השיטה 'put()' משמשת כדי למקם את הפריטים בתור. לאחר מכן, כדי לשלוף את המספרים מהתור ולהחזיר את הערכים שלהם, אנו כותבים פונקציה נוספת וקוראים לה במהלך ההליך. אנו משתמשים בפונקציה 'get()' כדי לאחזר את המספרים מהתור מכיוון ששיטה זו משמשת לאחזור הנתונים מהתור שאנו מכניסים בשיטת 'put()'.
בואו נתחיל ליישם את הקוד עכשיו. ראשית, אנו מייבאים את ארבע הספריות המרכיבות את הסקריפט הזה. אנו מייבאים תחילה 'שינה' ממודול הזמן כדי לעכב את הביצוע למשך זמן מה שנמדד בשניות, ואחריו 'אקראי' מהמודול האקראי המשמש ליצירת מספרים אקראיים, ולאחר מכן 'מעבדים' מעיבוד ריבוי מכיוון שקוד זה יוצר תהליך , ולבסוף, ה'תור' מ-multiprocessing. על ידי בנייה ראשונית של מופע מחלקה, ניתן להשתמש בתור. כברירת מחדל, זה יוצר תור אינסופי או תור ללא גודל מקסימלי. על ידי הגדרת אפשרות הגודל המקסימלי למספר שהוא גדול מאפס, ניתן ליצור יצירה עם הגבלת גודל.
אנו מגדירים פונקציה. לאחר מכן, מכיוון שפונקציה זו מוגדרת על ידי משתמש, אנו נותנים לה את השם 'פונקציה1' ומעבירים את המונח 'תור' כארגומנט שלה. לאחר מכן, אנו מפעילים את הפונקציה 'print()', ומעבירים לה את ההצהרות 'Builder: Running', 'Flush' והאובייקט 'True'. לפונקציית ההדפסה של Python יש אפשרות ייחודית הנקראת flush המאפשרת למשתמש לבחור אם לאמץ פלט זה או לא. השלב הבא הוא יצירת המשימה. לשם כך, אנו משתמשים ב-'for' ויוצרים את המשתנה 'm' ומגדירים את הטווח ל-'5'. לאחר מכן, בשורה הבאה, השתמש ב-'random()' ואחסן את התוצאה במשתנה שיצרנו שהוא 'value'. זה מציין שהפונקציה מסיימת כעת את חמש האיטרציות שלה, כאשר כל איטרציה יוצרת מספר שלם אקראי מ-0 עד 5.
לאחר מכן, בשלב הבא, אנו קוראים לפונקציה 'sleep()' ומעבירים את הארגומנט 'value' כדי לעכב את החלק למספר מסוים של שניות. לאחר מכן, אנו קוראים ל'תור' עם שיטת 'put()' כדי להוסיף למעשה את הערך לתור. לאחר מכן מודיעים למשתמש שאין עבודה נוספת לעשות על ידי הפעלת שיטת 'queue.put()' פעם נוספת והעברת הערך 'None'. לאחר מכן, אנו מפעילים את שיטת 'print()', מעבירים את המשפט 'builder: ready' יחד עם 'flush' ומגדירים אותה ל-'True'.
כעת אנו מגדירים פונקציה שנייה, 'פונקציה2', ומקצים לה את מילת המפתח 'תור' כארגומנט שלה. לאחר מכן, אנו קוראים לפונקציה 'print()' תוך העברת הדוח אומר 'משתמש: פועל' ו-'שטיפה' שמוגדרת ל'True'. אנו מתחילים את הפעולה של 'function2' תוך שימוש בתנאי while true כדי להוציא את הנתונים מהתור ולשים אותם במשתנה החדש 'item' שנוצר. לאחר מכן, אנו משתמשים בתנאי 'אם', 'פריט אינו', כדי לקטוע את הלולאה אם התנאי נכון. אם אין פריט זמין, הוא נעצר ומבקש מהמשתמש אחד. המשימה עוצרת את הלולאה ומסתיימת במקרה זה אם הפריט שמתקבל מהערך הוא null. לאחר מכן, בשלב הבא, אנו קוראים לפונקציה 'print()' ומספקים לה את הדוח 'User: ready' ופרמטרים 'flush=True'.
לאחר מכן, אנו נכנסים לתהליך הראשי באמצעות ה-'If-name = main_'. אנו יוצרים תור על ידי קריאה למתודה 'queue()' ושמירתה במשתנה 'queue'. לאחר מכן, אנו יוצרים תהליך על ידי קריאה לפונקציית המשתמש 'function2'. לשם כך, אנו קוראים למחלקה 'תהליך'. בתוכו, אנו מעבירים את ה-'target=function2' כדי לקרוא לפונקציה בתהליך, מעבירים את הארגומנט 'queue' ומאחסנים אותו במשתנה 'User_process'. לאחר מכן, התהליך מתחיל בקריאה למתודה 'start()' עם המשתנה 'User_ process'. לאחר מכן אנו חוזרים על אותו הליך כדי לקרוא ל-'function1' בתהליך ומכניסים אותו למשתנה 'תהליך בונה'. לאחר מכן, אנו קוראים לתהליכים עם השיטה 'join()' כדי להמתין לביצוע.
כעת כשהיא מוצגת, תוכל לראות את ההצהרות של שתי הפונקציות בפלט. הוא מציג את הפריטים שהוספנו באמצעות 'put()' ו-'get()' באמצעות שיטות 'get()', בהתאמה.
סיכום
למדנו על תור ריבוי העיבודים של Python במאמר זה. השתמשנו באיורים שניתנו. תחילה תיארנו כיצד ליצור תור בריבוי עיבודים של Python באמצעות הפונקציה queue() . לאחר מכן, השתמשנו בשיטה 'qsize()' כדי לקבוע את התור של . השתמשנו גם בשיטות put() ו-get() של התור. מחלקת השינה של מודול הזמן והמעמד האקראי של המודול האקראי נדונו שניהם בדוגמה האחרונה.