מהו ExecutorService ב- Java וכיצד ליצור אותו?

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

שפת התכנות של ג'אווה עובדת איתה ביעילות רבה יישומים הדורשים ביצוע המשימות במקביל בשרשור. קשה לכל יישום לבצע מספר רב של שרשורים בו זמנית. אז כדי להתגבר על הבעיה הזו, מגיע עם ExecutorService המהווה ממשק משנה של ה- . במאמר זה נדון בפונקציונליות של ExecutorService ב- Java. להלן הנושאים הניתנים בבלוג זה:

מהי Framework Framework?

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





המוציא לפועל הוא א עוזר לך ביצירה וניהול שרשורים ביישום. ה עוזר לך במשימות הבאות.

  • יצירת חוטים: היא מספקת מגוון שיטות ליצירת שרשורים המסייעים בהפעלת היישומים שלך במקביל.



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

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

service-executorservice ב- java -edureka

ExecutorService בדוגמה של Java

זהו ממשק משנה של מסגרת הפועל שמוסיף פונקציות מסוימות לניהול מחזור חיי השרשור של יישום. הוא גם מספק שיטת שלח () שיכולה לקבל ריצה וניתנת להתקשרות חפצים.



בדוגמה הבאה ניצור ExecutorService עם שרשור יחיד ואז נגיש את המשימה שתבוצע בתוך השרשור.

ייבא java.util.concurrent.ExecutorService ייבא java.util.concurrent.Executors מחלקה ציבורית דוגמה {main public static void (String [] args) {System.out.println ('Inside:' + Thread.currentThread (). getName ( )) System.out.println ('יצירת ExecutorService') ExecutorService executorservice = Executors.newSingleThreadExecutor () System.out.println ('יצירת ריצה') ניתן להריצה runnable = () -> {System.out.println ('בפנים: '+ Thread.currentThread (). GetName ())} System.out.println (' שלח את המשימה שצוינה על ידי הריצה לשירות המבצעת ') executorservice.submit (ניתן להפעיל)}}
 תְפוּקָה: בפנים: ראשי יוצר ExecutorService יצירת ריצה ניתן להגיש את המשימה שצוינה על ידי הרצה לשירות המבצעת בפנים: בריכה-1-שרשור-1

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

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

יישומי Java ExecutorService

ExecutorService דומה מאוד לבריכת אשכולות. למעשה, יישום ה- ExecutorService ב- java.util.concurrent חֲבִילָה הוא יישום threadpool. ל- ExecutorService יש את היישומים הבאים בחבילה java.util.concurrent:

ThreadPoolExecutor

ThreadPoolExecutor מבצע את המשימות הנתונות באמצעות אחד מהשרשורים הפנימיים שלו.

יצירת threadPoolExecutor

int corePoolSize = 5 int maxPoolSize = 10 keepAliveTime long = 5000 ExecutorService threadPoolExecutor = threadread חדש PoolExecutor (corePoolSize, maxPoolSize, keepAliveTime, TimeUnit.MILLISECONDS, חדש LinkedBlockingQueue ())

ScheduledThreadPoolExecutor

Java.util.concurrent.ScheduledThreadPoolExecutor הוא ExecutorService שיכול לתזמן משימות להפעלה לאחר עיכוב או לבצע שוב ושוב עם מרווח זמן קבוע בין כל ביצוע.

דוגמא

ScheduledExecutorService scheduledexecutorservice = Executors.newScheduledThreadPool (5) ScheduledFuture schedulfuture = scheduledExecutorService.schedule (Callable חדש () {public object call () זורק Exception {System.out.println ('executed') return 'called'}}, 5, TimeUnit. שניות)

שימוש ב- ExecutorService

ישנן מספר דרכים שונות להאציל משימות ל- ExecutorService.

  • לבצע (ניתן להפעיל)

  • הגש (ניתן להפעיל)

  • להפעיל את כל ()

  • הפעל את כל ()

ביצוע Runnable

Java ExecutorService execute (Runnable) לוקח אובייקט java.lang.Runnable ומבצע אותו באופן אסינכרוני.

ExecutorService executorService = Executors.newSingleThreadExecutor () executorService.execute (חדש Runnable () {public void run () {System.out.println ('משימה אסינכרונית')}}) executorService.shutdown ()

אין דרך להשיג את התוצאה של ה- Runnable לבצע, לשם כך אתה צריך להשתמש ב- Callable.

הגש Runnable

שיטת ההגשה של Java ExecutorService (Runnable) לוקחת יישום Runnable ומחזירה אובייקט עתידי. בעזרת האובייקט העתידי ניתן לבדוק אם ה- Runnable סיים לבצע.

עתיד עתידי = executorService.submit (חדש Runnable () {public void run () {System.out.println (: asynchronous task ')}}) future.get () // מחזיר null אם המשימה הסתיימה כהלכה.

הגש להתקשרות

שיטת ההגשה של Java ExecutorService (Callable) דומה ל- Send (Runnable) אך נדרשת Java Callable במקום Runnable.

עתיד עתידי = executorService.submit (קריאה חדשה () {קריאה של אובייקט ציבורי () זורקת חריג {System.out.println ('Asynchronous callable') מחזירה 'תוצאה מתקשרת'}}) System.out.println ('future.get ( ) = 'future.get ())
 תְפוּקָה: Future.get ניתן להתקשר לאסינכר. = תוצאה הניתנת להתקשרות

להפעיל את כל ()

השיטה invokeAny () לוקחת אוסף של אובייקטים הניתנים להתקשרות. הפעלת שיטה זו אינה מחזירה עתיד, אלא מחזירה את התוצאה של אחד האובייקטים הניתנים להתקשרות.

ExecutorService executorService = הגדר Executors.newSingleThreadExecutor ()callables = HashSet חדש() callables.add (new Callable () {public String call () זורק חריג {return'task A '}}) callables.add (new Callable () {public String call () זורק Exception {return'task B'} }) callables.add (חדש Callable () {public String call () זורק Exception {return'task C '}}) String result = executorService.invokeAny (callables) System.out.println (' result = '+ result) executorService .לכבות()

כאשר אתה מריץ את הקוד לעיל, התוצאה משתנה. זה יכול להיות משימה א ', משימה ב' וכן הלאה.

InvokeAll ()

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

ExecutorService executorService = הגדר Executors.newSingleThreadExecutor ()callables = HashSet חדש() callables.add (new Callable () {public String call () זורק Exception {return 'Task A'}}) callables.add (new Callable () {public String call () זורק Exception {return 'Task B'} }) callables.add (חדש Callable () {ציבורי מחרוזת () זורק חריג {להחזיר 'משימה C'}}) רשימהfutures = executorService.invokeAll (callables) עבור (עתיד עתידי: עתיד) {System.out.println ('future.get =' + future.get ())} executorService.shutdown ()

ניתן להריץ לעומת קריאה

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

הצהרה הניתנת להתקשרות:

ממשק ציבורי הניתן להתקשרות

הצהרה רצה:

ממשק ציבורי ניתן להריצה {run public public ()}

ההבדל העיקרי בין השניים הוא ששיטת call () יכולה להחזיר אובייקט משיחת השיטה. ושיטת call () יכולה לזרוק בעוד שיטת run () אינה יכולה.

קוד לדוגמא של פיתון רגרסיה לוגיסטית

בטל את המשימה

באפשרותך לבטל את המשימה שהוגשה ל- ExecutorService על ידי פשוט להתקשר לשיטת הביטול בעתיד שיוגש בעת הגשת המשימה.

future.cancel ()

כיבוי ExecutorService

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

לכבות()

כדי לסיים את האשכולות בתוך ExecutorService אתה יכול להתקשר לשיטת shutdown ().

executorService.shutdown ()

זה מביא אותנו לסוף מאמר זה בו למדנו כיצד אנו יכולים להשתמש ב- ExecutorService לביצוע משימות בשרשור. אני מקווה שברור לך עם כל מה ששותף איתך במדריך זה.

אם מצאת מאמר זה בנושא 'ExecutorService ב- Java' רלוונטי, עיין בכתובת חברת למידה מקוונת אמינה עם רשת של יותר מ -250,000 לומדים מרוצים הפרוסים ברחבי העולם.

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

אם אתה נתקל בשאלות כלשהן, אל תהסס לשאול את כל השאלות שלך בקטע ההערות של 'ExecutorService ב- Java' והצוות שלנו ישמח לענות.