streamalism.org

1. הקדמה

במאמר זה נתמקד ב PriorityBlockingQueue שיעורים ועברו על כמה דוגמאות מעשיות.

החל מההנחה שאנחנו כבר יודעים מה א תוֹר הוא, נדגים תחילה איך אלמנטים ב PriorityBlockingQueue מסודרים לפי עדיפות.

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

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

2. עדיפות אלמנטים

שלא כמו תור רגיל, אינך יכול להוסיף סתם רכיב כלשהו ל- a PriorityBlockingQueue. ישנן שתי אפשרויות:

1. הוספת אלמנטים אשר מיישמים ניתן להשוות
2. הוספת אלמנטים שאינם מיושמים ניתן להשוות, בתנאי שתספק א משווה גם כן

באמצעות או משווה או ה ניתן להשוות יישומים להשוואת אלמנטים, PriorityBlockingQueue תמיד ימוינו.

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

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

PriorityBlockingQueue queue = PriorityBlockingQueue חדש (); ArrayList polledElements = ArrayList חדש (); תור. להוסיף (1); תור. להוסיף (5); תור. להוסיף (2); תור. להוסיף (3); תור. להוסיף (4); queue.drainTo (polledElements); assertThat (polledElements). מכיל בדיוק (1, 2, 3, 4, 5);

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

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

3. באמצעות תוֹר לחסום

אם עסקינן בתור סטנדרטי, היינו מתקשרים מִשׁאָל() כדי לאחזר אלמנטים. עם זאת, אם התור היה ריק, התקשר אל מִשׁאָל() יחזור ריק.

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

PriorityBlockingQueue queue = PriorityBlockingQueue חדש (); שרשור חדש (() -> {System.out.println ("סקר ..."); נסה את {Integer poll = queue.take (); System.out.println ("Polled:" + poll);} לתפוס ( InterruptedException e) {e.printStackTrace ();}}). התחל (); Thread.sleep (TimeUnit.SECONDS.toMillis (5)); System.out.println ("מוסיף לתור"); תור. להוסיף (1);

למרות שימוש לִישׁוֹן() זו דרך שבירה מעט להפגין דברים, כאשר אנו מריצים את הקוד הזה נראה:

סקר ... מוסיף לתור שנחקר: 1 

זה מוכיח את זה לקחת() חסום עד שנוסף פריט:

1. החוט ידפיס "Polling" כדי להוכיח שהוא התחיל
2. לאחר מכן הבדיקה תשהה כחמש שניות, כדי להוכיח שהחוט בטח התקשר לקחת() בנקודה זו
3. אנו מוסיפים לתור, ואנחנו צריכים לראות פחות או יותר באופן מיידי את "Polled: 1" כדי להוכיח זאת לקחת() החזיר אלמנט ברגע שהוא זמין

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

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

4. שימוש בחסימה ובתעדוף יחד

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

שרשור הברגה = שרשור חדש (() -> {System.out.println ("סקר ..."); בעוד (נכון) {נסה {סקר שלם = queue.take (); System.out.println ("סקר: "+ סקר);} לתפוס (InterruptedException e) {e.printStackTrace ();}}}); thread.start (); Thread.sleep (TimeUnit.SECONDS.toMillis (5)); System.out.println ("מוסיף לתור"); queue.addAll (newArrayList (1, 5, 6, 1, 2, 6, 7)); Thread.sleep (TimeUnit.SECONDS.toMillis (1));

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

סקר ... מוסיף לתור סקר: 1 סקר: 1 סקר: 2 סקר: 5 סקר: 6 סקר: 6 סקר: 7

5. מסקנה

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

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