המסגרת לפועל כבר הציגה ב- Java 1.5 וזה חלק מחבילת java.util.concurrent. המסגרת לפועל היא הפשטה על יישום בפועל של multithreading Java. הוא משמש לתקנון קריאה, תזמון, ביצוע ובקרה של משימות אסינכרוני פי סט של מדיניות ביצוע המוגדר במהלך היצירה של הבנאי.
לפני ג 'אווה 1.5, יישומי multithreading נוצרו באמצעות קבוצת חוט , בריכת חוט או חוט בריכה מותאמת אישית. עכשיו השליטה של כל חוט שצריך לעשות על ידי המתכנת תוך התחשבות בנקודות הבאות
● סנכרון
● נעילה
● הודעה
● נעילת המלח
ועוד רבים שנובע מדרישת היישום. Some time it is very difficult to control multithreading applications because the behaviors of the threads are also dependent on the environment where the application is deployed and running. For example the processor speed, the RAM size, the band width all has a direct effect on the multithreading application. So you have to keep all these factors in mind before creating architecture.
An Executor framework provides multi-threading application programs with a easy abstraction for thinking about tasks. Instead of thinking in terms of threads, an application now deals simply with instances of Runnable (which is basically collections of tasks). And then it is passed to an Executor to process. ממשק ExecutorService מרחיב את ממשק הפועל הפשטני ויש שיטות מחזור חיים לניהול מסגרת המוציא לפועל.
מסגרת הפועל מייצגת משימות באמצעות מקרים של Runnable או callable. הריצה של Runnable () שיטה לא להחזיר ערך או לזרוק חריג בדק. Callable הוא גרסה פונקציונלית יותר באזור זה. הוא מגדיר שיחה () שיטה המאפשרת את החזרת כמה ערך מחושב שניתן להשתמש בעיבוד עתיד. וזה גם זורק חריג במידת צורך.
כיתת FutureTask משמשת כדי לקבל מידע על עתיד העיבוד. מופע של מחלקה זו יכול לעטוף גם callable או Runnable. אתה יכול לקבל דוגמא של זה כערך ההחזרה של להגיש () שיטה של ExecutorService. גם אתה יכול לעטוף באופן ידני המשימה שלך בFutureTask לפני שקראת לבצע () שיטה.
להלן צעדי הפונקציה ליישם ThreadPoolExecutor.
● בריכה של חוט מרובה / יחיד נוצר.
● תור נוצר מחזיק את כל המשימות אבל משימות אלה עדיין לא הוקצו לנושאים מהברכה. מתוחם ותורים בלתי מוגבל זמינים.
● מטפל דחייה משמש לטיפול במצב שבו אחת או יותר משימות אינן יכולים להקצות בתור. בהתאם למדיניות דחיית ברירת המחדל, זה יהיה פשוט לזרוק חריג זמן ריצה RejectedExecutionException, והיישום יכול לתפוס אותו או למחוק אותו.
להלן דוגמא להתבונן מחזור החיים של מסגרת מוציא לפועל. כאן אנו רק לדון בצעדי הבסיס והממשקים הבסיסיים. יש הרבה יותר תכונות וsubclasses זמינים לטפל סוג של צורך המבקש שונה.
הכיתה הבאה מיישמת Runnable והמופעים שלה ישמשו כמשימה בסעיף הבא של קוד.
public class jobPrint implements Runnable {
private final String name;
private final int delay;
public jobPrint(String name, int delay) {
this.name = name;
this.delay = delay;
}
public void run() {
System.out.println("Starting: " + name);
try {
Thread.sleep(delay);
} catch (InterruptedException ignored) {
}
System.out.println("Done with: " + name);
}
}
הכיתה הבאה מיישמת את משימות מוציא לפועל.
import java.util.concurrent.*;
import java.util.Random;
UseExecutorService מעמד ציבורי {
הריק סטטי הראשי ציבורי(args מחרוזת[]) {
אקראי אקראי אקראי = חדש();
מוציא לפועל ExecutorService = Executors.newFixedThreadPool(3);
// סיכום זמני ההמתנה לדעת מתי כיבוי
int waitTime = 500;
עבור (int i = 0; אני<10; אני ) {
שם מיתרים = “NamePrinter ” + אני;
זמן int = random.nextInt(1000);
waitTime = זמן;
רץ Runnable = jobPrint החדש(שם, זְמַן);
שיטה(“מוֹסִיף: ” + שם + ” / ” + זְמַן);
executor.execute(רָץ);
}
לנסות {
Thread.sleep(waitTime);
executor.shutdown();
executor.awaitTermination
(waitTime, TimeUnit.MILLISECONDS);
} לתפוס (InterruptedException התעלם) {
}
System.exit(0);
}
}
צור מוציא לפועל
ראשון ליצור מופע של מוציא לפועל או ExecutorService. יש מעמד לפועל מספר שיטות מפעל סטטי ליצור ExecutorService. For example, newFixedThreadPool() חוזר למשל ThreadPoolExecutor עם תור ומספר קבוע של נושאים אותחל וחסר גבולות. וnewCachedThreadPool () חוזר למשל ThreadPoolExecutor אותחל עם תור בלתי מוגבל ובלתי מוגבל של מספר אשכולות. במקרה 2, אשכולות קיימים בה שימוש חוזר, אם חוט לא חופשי available.If זמין, אחד חדש נוצר והוסיף לבריכה. נושאים שהיו פעיל במשך זמן רב יותר מזמן קצוב יוסרו באופן אוטומטי מהברכה.
זוהי בריכה קבועה של 15 אשכולות.
מוציא לפועל מוציא לפועל פרטי סטטי סופי = Executors.newFixedThreadPool(15);
זוהי בריכת חוט מטמון
exec ExecutorService סטטי הפרטי = Executors.newCachedThreadPool();
Following is a customized thread pool executor. The parameter values depend upon the application need. Here the core pool is having 5 threads which can run concurrently and the maximum number is 10. The queue is capable of keeping 200 tasks. Here one point should be remembered that the pool size should be kept on a higher side to accommodate all tasks. The idle time limit is kept as 5 ms.
private static final Executor executor = new ThreadPoolExecutor(5, 10, 50000L, TimeUnit.MILLISECONDS, new LinkedBlockingQueue(200));
Create one or more tasks and put in the queue
Create one or more tasks to be performed as instances of either Runnable or Callable.
Submit the task to the Executor
After creating the ExecutorService, you need to submit a task to it by using either submit () or execute () שיטה. עכשיו חוט חופשי מהברכה באופן אוטומטי לקחת המשימות מהתור ולבצע אותה. עכשיו התהליך ימשיך עד שכל המשימות שתסיים מהתור.
לבצע את המשימה
עכשיו המוציא לפועל הוא אחראי לניהול הביצוע של המשימה, בריכת חוט ותור. אם הבריכה יש פחות מהמספר המוגדר של נושאים מינימום, נושאים חדשים ייווצרו להתמודד עם משימות בתור עד שהגיעה למגבלה שלערך המוגדר. אם המספר הוא גבוה יותר מהמינימום המוגדר, אז הבריכה לא תתחיל עוד נושאים. במקום זאת, המשימה בתור עד חוט משוחרר עד כדי לעבד את הבקשה. אם התור מלא, אז חוט חדש התחיל להתמודד עם זה.
כיבוי הפועל
הסיום מבוצע על ידי הפנייה כיבויה () שיטה. אתה יכול לבחור להפסיק את זה בחינניות, או בפתאומיות.
זה פוסט נהדר על ריבוי המשימות בJava
Thanks
/Jhon