‫‪ Active Object, Threads‬ו‪:Future -‬‬

‫‪:Active Object‬‬

‫אובייקט המייצג משימה אסינכרונית‪.‬‬ ‫●‬

‫אחראי לניהול ביצוע המשימה‪ ,‬כולל ניהול שרשורים וזיכרון‪.‬‬ ‫●‬
‫מספק ממשק פשוט לשימוש‪ ,‬ומסתיר את פרטי הניהול הנמוך של שרשורים‪.‬‬ ‫●‬
‫דוגמאות‪ExecutorService, Callable, FutureTask :‬‬ ‫●‬
‫‪ :Generic Active Object‬מאפשר עבודה עם סוגים כלליים של נתונים במקום סוגים‬ ‫●‬
‫ספציפיים‪.‬‬
‫‪ :Reactive Streams‬ממשק אחיד להזרמת נתונים בין אקטיב אובג'קטים שונים‪.‬‬ ‫●‬

‫‪:Thread‬‬

‫יחידת ביצוע בסיסית ב‪.Java-‬‬ ‫●‬

‫מאפשרים ביצוע משימות מרובות באופן מקבילי‪.‬‬ ‫●‬
‫דורשים ניהול ידני של משאבים‪ ,‬כמו שרשורים וזיכרון‪.‬‬ ‫●‬
‫דוגמאות‪Thread, Runnable :‬‬ ‫●‬
‫‪ :Daemon threads‬ת'רדים שאינם חשובים להמשך ביצוע התוכנית ויכולים להיות‬ ‫●‬
‫מופסקים בכל עת‪.‬‬
‫‪ :User threads‬ת'רדים החשובים להמשך ביצוע התוכנית ואינם יכולים להיות מופסקים‬ ‫●‬
‫בצורה שרירותית‪.‬‬

‫‪:Future‬‬

‫מייצג את התוצאה של משימה אסינכרונית‪.‬‬ ‫●‬

‫מאפשר גישה לתוצאה של המשימה לאחר שהיא הסתיימה‪.‬‬ ‫●‬
‫ניתן להשתמש בו כדי לבצע משימות באופן אסינכרוני ולקבל את התוצאה שלהן מאוחר יותר‪.‬‬ ‫●‬
‫דוגמאות‪Future, CompletableFuture :‬‬ ‫●‬
‫‪ :Real Future‬מייצג תוצאה שטרם חושבה אך תהיה זמינה בהמשך‪.‬‬ ‫●‬
‫‪ :Fake Future‬מייצג תוצאה שכבר חושבה וזמינה מיד‪.‬‬ ‫●‬
‫(הרחבה בהמשך)‬

‫למה משמש כל אחד‪:‬‬

‫‪ :Active Object‬משמש לניהול קל ויעיל של משימות אסינכרוניות‪.‬‬ ‫●‬

‫‪ :Thread‬משמשים לביצוע משימות מרובות באופן מקבילי‪.‬‬ ‫●‬
‫‪ :Future‬משמש לקבלת התוצאה של משימה אסינכרונית לאחר שהיא הסתיימה‪.‬‬ ‫●‬

‫מתי להשתמש בכל אחד‪:‬‬

‫‪ :Active Object‬כאשר נדרש לבצע משימות אסינכרוניות בצורה פשוטה ויעילה‪.‬‬ ‫●‬
‫‪ :Thread‬כאשר נדרש שליטה רבה יותר בביצוע המשימות‪.‬‬ ‫●‬
‫‪ :Future‬כאשר נדרש לקבל את התוצאה של משימה אסינכרונית לאחר שהיא הסתיימה‪.‬‬ ‫●‬

‫מתודות‪:‬‬

‫‪:Active Object‬‬ ‫●‬

‫‪ :)(submit‬הגשת משימה לביצוע‪.‬‬ ‫○‬
‫‪ :)(execute‬הפעלת משימה באופן מיידי‪.‬‬ ‫○‬
‫‪ :)(shutdown‬כיבוי אקטיב אובג'קט‪.‬‬ ‫○‬
 ‫‪ :)(awaitTermination‬המתנה עד לסיום ביצוע כל המשימות‪.‬‬ ‫○‬
‫‪:Thread‬‬ ‫●‬
‫‪ :)(start‬הפעלת שרשור‪.‬‬ ‫○‬
‫‪ :)(run‬שיטת הביצוע של שרשור‪.‬‬ ‫○‬
‫‪ :)(join‬המתנה לסיום ביצוע שרשור‪.‬‬ ‫○‬
‫‪:Future‬‬ ‫●‬
‫‪ :)(get‬קבלת התוצאה של משימה‪.‬‬ ‫○‬
‫‪ :)(isDone‬בדיקה אם המשימה הסתיימה‪.‬‬ ‫○‬
‫‪ :)(cancel‬ביטול המשימה‪.‬‬ ‫○‬

‫טבלת סיכום‪:‬‬

‫נושאים קשורים‪:‬‬

‫‪ :Callable‬ממשק המאפשר החזרת ערך מתוך משימה אסינכרונית‪.‬‬ ‫●‬

‫‪ :CompletableFuture‬מימוש מתקדם של פיוצ'ר המאפשר ביצוע פעולות מורכבות בצורה‬ ‫●‬
‫נוחה‪.‬‬
‫‪ :ForkJoinPool‬מסגרת לביצוע משימות באופן מקבילי תוך ניצול רב של מעבדים‪.‬‬ ‫●‬
‫‪ :Stream API‬מסגרת עבודה עם נתונים באופן פונקציונלי ותומך בביצוע פעולות באופן‬ ‫●‬
‫מקבילי‪.‬‬

‫‪:ExecutorService‬‬
‫‪ ExecutorService‬הוא ממשק ב‪ Java-‬המאפשר ניהול וביצוע משימות באופן אסינכרוני ובמקביל‪.‬‬
‫הוא מספק פונקציונליות בסיסית לניהול שרשורים‪ ,‬כמו הגשת משימות לביצוע‪ ,‬ביטול משימות‬
‫והמתנה לסיום ביצוע משימות‪.‬‬

‫שימושים ב‪:ExecutorService-‬‬

‫ביצוע משימות ארוכות ברקע ללא חסימת התוכנית‪.‬‬ ‫●‬

‫ביצוע משימות מקביליות לשם שיפור הביצועים‪.‬‬ ‫●‬
‫ניהול מספר רב של משימות באופן יעיל‪.‬‬ ‫●‬

‫יתרונות השימוש ב‪:ExecutorService-‬‬

 ‫פשטות‪ :‬קל לשימוש ומספק ממשק פשוט לניהול משימות‪.‬‬ ‫●‬
‫גמישות‪ :‬מאפשר ביצוע משימות באופן אסינכרוני ובמקביל בצורה גמישה‪.‬‬ ‫●‬
‫יעילות‪ :‬מנהל את השרשורים באופן יעיל ומנצל את משאבי המחשב באופן מיטבי‪.‬‬ ‫●‬

‫דוגמאות לשימוש ב‪:ExecutorService-‬‬

‫ביצוע בדיקות יחידה באופן מקבילי‪.‬‬ ‫●‬

‫הורדת קבצים מאינטרנט ברקע‪.‬‬ ‫●‬
‫עיבוד נתונים באופן מקבילי‪.‬‬ ‫●‬

‫הערה‪:‬‬

‫‪ ExecutorService‬הוא ממשק כללי‪ ,‬ולכן יש לממש אותו בצורה ספציפית כדי להשתמש בו‪ .‬קיימות‬
‫מספר מימושים פופולריים של ‪ ,ExecutorService‬כמו ‪ ThreadPoolExecutor‬ו‪.ForkJoinPool-‬‬

‫‪ Callable‬ו‪:Runnable-‬‬
‫‪:Callable‬‬

‫ממשק ב‪ Java-‬המגדיר שיטה אחת‪.)(call :‬‬ ‫●‬

‫משמש לייצוג משימה אסינכרונית שיכולה להחזיר ערך‪.‬‬ ‫●‬
‫ניתן להשתמש בו עם ‪ ExecutorService‬כדי להפעיל משימות אסינכרוניות ולקבל את‬ ‫●‬
‫התוצאות שלהן‪.‬‬

‫‪:Runnable‬‬

‫ממשק ב‪ Java-‬המגדיר שיטה אחת‪.)(run :‬‬ ‫●‬

‫משמש לייצוג משימה אסינכרונית שאינה מחזירה ערך‪.‬‬ ‫●‬
‫ניתן להשתמש בו עם ‪ Thread‬כדי להפעיל משימות אסינכרוניות‪.‬‬ ‫●‬

‫ההבדלים בין ‪ Callable‬ו‪:Runnable-‬‬

‫החזרת ערך‪ Callable :‬יכול להחזיר ערך מסוג כלשהו‪ ,‬בעוד ש‪ Runnable-‬אינו מחזיר ערך‪.‬‬ ‫●‬
‫שימוש‪ Callable :‬משמש בדרך כלל עם ‪ ,ExecutorService‬בעוד ש‪ Runnable-‬משמש‬ ‫●‬
‫בדרך כלל עם ‪.Thread‬‬

‫‪ ThreadPool‬ו‪:ParallelPool-‬‬
‫‪:ThreadPool‬‬

‫מאגר של שרשורים הזמינים לביצוע משימות‪.‬‬ ‫●‬

‫מאפשר ניהול יעיל של משאבים כמו שרשורים וזיכרון‪.‬‬ ‫●‬
‫מספק מספר יתרונות‪ ,‬ביניהם‪:‬‬ ‫●‬
‫ביצוע משימות באופן מקבילי‬ ‫○‬
‫○ שיפור הביצועים‬
‫הפחתת עומס על המעבד‬ ‫○‬
 ‫‪:ParallelPool‬‬

‫מימוש ספציפי של ‪ ThreadPool‬המתאים לביצוע משימות מקביליות בצורה יעילה‪.‬‬ ‫●‬

‫משתמש ב‪ ForkJoinPool-‬כדי לפרק משימות למשימות קטנות יותר ולבצע אותן באופן‬ ‫●‬
‫מקבילי‪.‬‬
‫מספק מספר יתרונות‪ ,‬ביניהם‪:‬‬ ‫●‬
‫ביצוע משימות באופן מקבילי יעיל‬ ‫○‬
‫הקטנת עומס על המעבד‬ ‫○‬
‫○ שיפור הביצועים‬

‫ההבדלים בין ‪ ThreadPool‬ו‪:ParallelPool-‬‬

‫מימוש‪ ThreadPool :‬הוא ממשק כללי‪ ,‬בעוד ש‪ ParallelPool-‬הוא מימוש ספציפי של‬ ‫●‬
‫‪.ThreadPool‬‬
‫התאמה‪ ThreadPool :‬מתאים למגוון רחב של משימות‪ ,‬בעוד ש‪ ParallelPool-‬מתאים‬ ‫●‬
‫בעיקר למשימות מקביליות‪.‬‬
‫ביצועים‪ ParallelPool :‬עשוי להציע ביצועים טובים יותר מ‪ ThreadPool-‬עבור משימות‬ ‫●‬
‫מקביליות‪.‬‬

‫‪ Real Future‬ו‪:Fake Future-‬‬

‫‪:Real Future‬‬

‫מייצג תוצאה שטרם חושבה אך תהיה זמינה בהמשך‪.‬‬ ‫●‬

‫משמש לביצוע משימות באופן אסינכרוני והחזרת התוצאה להמשך הטיפול במועד מאוחר‬ ‫●‬
‫יותר‪.‬‬
‫ניתן להשתמש ב‪ Future-‬אמיתי כדי להימנע מחסימה של התוכנית בעת המתנה לתוצאה‬ ‫●‬
‫של משימה ארוכה‪.‬‬

‫‪:Fake Future‬‬

‫מייצג תוצאה שכבר חושבה וזמינה מיד‪.‬‬ ‫●‬

‫משמש לביצוע משימות באופן סינכרוני והחזרת התוצאה מיד לאחר השלמת הביצוע‪.‬‬ ‫●‬
‫ניתן להשתמש ב‪ Future-‬מתחזה כדי להימנע מהוספת מורכבות לתוכנית בעת ביצוע‬ ‫●‬
‫משימות קצרות ופשוטות‪.‬‬

‫השוואה בין ‪ Real Future‬ו‪:Fake Future-‬‬

 ‫‪:ForkJoinPool‬‬

‫‪ ForkJoinPool‬הוא מימוש ספציפי של ‪ ExecutorService‬המתאים לביצוע משימות מקביליות‬

‫בצורה יעילה‪ .‬הוא משתמש ב‪ Fork/Join framework-‬כדי לפרק משימות למשימות קטנות יותר‬
‫ולבצע אותן באופן מקבילי‪.‬‬

‫יתרונות ‪:ForkJoinPool‬‬

‫ביצועים‪ ForkJoinPool :‬עשוי להציע ביצועים טובים יותר מ‪ ThreadPoolExecutor-‬עבור‬ ‫●‬

‫משימות מקביליות‪.‬‬
‫הקטנת עומס על המעבד‪ ForkJoinPool :‬מנסה לנצל את כל ליבות המעבד באופן יעיל‬ ‫●‬
‫ולמנוע עומס יתר על ליבה בודדת‪.‬‬

‫מימוש ‪ ForkJoinPool‬באופן גנרי‪:‬‬

‫הגדרת משימה‪ :‬צור מחלקה המממשת את הממשק ‪ .ForkJoinTask‬המחלקה צריכה‬ ‫‪.1‬‬

‫להגדיר את השיטה ‪ )(compute‬המבצעת את המשימה‪.‬‬
‫יצירת ‪ :ForkJoinPool‬צור מופע של ‪ ForkJoinPool‬עם מספר השרשורים הרצוי‪.‬‬ ‫‪.2‬‬
‫הגשת משימה‪ :‬השתמש ב‪ )(submit-‬כדי להגיש את המשימה ל‪.ForkJoinPool-‬‬ ‫‪.3‬‬
‫המתנה לסיום‪ :‬השתמש ב‪ )(join-‬כדי להמתין לסיום ביצוע המשימה‪.‬‬ ‫‪.4‬‬