Կատարողը շրջանակը, Java, Բազմահոսքայնություն

The Executor Framework has been introduced in Java 1.5 and it is a part of java.util.concurrent package. The Executor framework is an abstraction over the actual implementation of java multithreading. It is used for standardizing invocation, scheduling, կատարումը եւ վերահսկողությունը տարաժամանակյա խնդիրների, ըստ մի շարք կատարման քաղաքականության սահմանված ստեղծման ժամանակ կառուցապատողի.

Մինչեւ java 1.5, Բազմահոսքայնություն ծրագրեր ստեղծվել են օգտագործում շարանը խումբ , թեմա լողավազան կամ մաքսային թեմա լողավազան. Այժմ վերահսկողությունը յուրաքանչյուր թելից պետք է արվի ի ծրագրավորողի պահելու մտքում հետեւյալ կետերը
● համաժամացման
● փական
● Notification
● Dead փական
Եւ շատ ավելին, որ ծագում դուրս է դիմումի պահանջը. Որոշ ժամանակ դա շատ դժվար է վերահսկել Բազմահոսքայնություն դիմումները, քանի որ վարքագծերը թեմաները են նաեւ կախված է շրջակա միջավայրի, որտեղ դիմումը տեղակայված եւ վարման. Օրինակ, պրոցեսոր արագություն, որ RAM չափը, որ խումբը լայնությունը բոլոր ունի անմիջական ազդեցություն multithreading դիմումի. Այսպիսով, դուք պետք է պահել այդ բոլոր գործոնները մտքում առաջ ստեղծել ճարտարապետությունը.
An Կատարողը շրջանակներում ապահովում է բազմաբնակարան threading դիմում ծրագրեր հեշտ աբստրակցիա մտածում խնդիրների. Փոխարենը մտածել առումով թեմաները, դիմում, այժմ զբաղվում պարզապես ատյաններում runnable (որը հիմնականում հավաքածուներ խնդիրների). Եվ ապա անցել է է Կատարողի ընթացք. The ExecutorService ինտերֆեյսը ընդլայնում է simplistic Կատարողի ինտերֆեյսի եւ կան կյանքի ցիկլի մեթոդները կառավարել կատարողի շրջանակը.
Կատարողը շրջանակը ներկայացնում խնդիրները, օգտագործելով ատյաններում runnable կամ հետկանչելի. Runnable ի Run () մեթոդը չի վերադառնա արժեք, կամ շպրտել մի ստուգվում բացառություն. Հետկանչելի է ավելի ֆունկցիոնալ տարբերակ այդ ոլորտում. Այն սահմանում է մի զանգ () մեթոդ, որը թույլ է տալիս վերադարձը որոշ հաշվարկված արժեքի, որոնք կարող են օգտագործվել հետագա մշակման. Եվ դա նաեւ նետում բացառություն անհրաժեշտության դեպքում.
The FutureTask դասը օգտագործվում է ստանալ ապագա մասին տեղեկատվություն վերամշակման. An ատյանը Այս դասի կարող եք փաթեթավորեք կամ հետկանչելի կամ runnable. Դուք կարող եք ստանալ ատյանի սա որպես վերադարձնելու արժեքի ներկայացնել () մեթոդ է ExecutorService. Դուք կարող եք նաեւ ձեռքով փաթեթավորեք ձեր խնդիրն է, որը FutureTask նախքան կանչում մահապատժի () մեթոդ.
Հետեւելով են ֆունկցիայի քայլեր իրականացնել ThreadPoolExecutor.
● Մի լողավազան բազմակի / մեկ հատից ստեղծվում.
● Մի հերթ է ստեղծվել, անցկացման բոլոր խնդիրները, բայց այդ խնդիրները դեռ չեն նշանակվում թեմաները ջրավազանի. Bounded եւ անսահման հերթեր են հասանելի.
● մերժումը handler օգտագործվում է կարգավորել իրավիճակը, երբ մեկ կամ ավելի առաջադրանքներ չեն կարողանում հանձնարարել է հերթում. Ըստ լռելյայն մերժման քաղաքականության, դա պարզապես շպրտել մի RejectedExecutionException Runtime բացառություն, եւ դիմումը կարող է բռնել այն, կամ մերժել այն.

Հետեւելով օրինակ է դիտարկել կյանքի ցիկլի մի կատարողի շրջանակում. Այստեղ մենք միայն քննարկելու հիմքը քայլերը, եւ հիմնական ինտերֆեյս. Կան շատ ավելի հատկություններ եւ ենթադասերի հասանելի է կարգավորել տարբեր տեսակի Դիմող կարիք.

Հետեւյալ դասի իրականացնում 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[]) {
Պատահական Պատահական = new Պատահական();
ExecutorService կատարողը = Executors.newFixedThreadPool(3);
// Ամփոփել է սպասման անգամ է իմանալ, թե երբ է անջատում
int waitTime = 500;
համար (int i = 0; ես<10; i ) {
String name = “NamePrinter ” + ես;
int ժամանակը = random.nextInt(1000);
waitTime = ժամանակը;
Runnable վազող = new jobPrint(անվանում, ժամանակ);
System.out.println(“Ավելացնելով: ” + անվանում + ” / ” + ժամանակ);
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 - րդ դեպքում,, առկա թեմաները reused եթե available.If ազատ թեմա հասանելի է, նորը ստեղծվել է եւ ավելացրել է լողավազանում. Թեմաներ, որոնք եղել պարապ ավելի երկար, քան timeout ժամանակահատվածում կհանվի ավտոմատ լողավազանում.
Սա ֆիքսված լողավազան 15 թեմաները.
անձնական ստատիկ վերջնական Կատարողը կատարողը = Executors.newFixedThreadPool(15);
Սա Պահված թեմա լողավազան
անձնական ստատիկ ExecutorService exec = Executors.newCachedThreadPool();
Ստորեւ ներկայացվում է մի հարմարեցված թեմա լողավազան կատարողը. Չափորոշիչը արժեքները կախված հայտի անհրաժեշտության. Այստեղ միջուկը լողավազան ունեցող 5 թեմաները որը կարող է միաժամանակ եւ առավելագույն թիվն է 10. Հերթ ի վիճակի է պահելու 200 tasks. Այստեղ մի կետ, պետք է հիշել, որ լողավազան չափը պետք է պահել ավելի բարձր կողմի տեղավորել բոլոր խնդիրները. The պարապ ժամկետը պահվում է 5 MS.
անձնական ստատիկ վերջնական Կատարողը կատարողը = new ThreadPoolExecutor(5, 10, 50000L, TimeUnit.MILLISECONDS, Նոր LinkedBlockingQueue(200));

Ստեղծել մեկ կամ ավելի խնդիրները եւ դնում է հերթում

Ստեղծել մեկ կամ ավելի առաջադրանքներ են կատարվում, քանի որ ատյաններում կամ runnable կամ հետկանչելի.

Ներկայացրեք խնդիրն է Կատարողի

Հետո ստեղծել ExecutorService, Դուք պետք է ներկայացնել մի խնդիր է այն, օգտագործելով կամ ներկայացնել () կամ կատարել () մեթոդ. Այժմ ազատ թեմա ջրավազանի ինքնաբերաբար վերցնել խնդիրներն են հերթում եւ կատարել այն. Այժմ այդ գործընթացը շարունակվելու է մինչեւ բոլոր խնդիրները, որոնք ավարտվել են հերթում.

Իրականացնում է խնդիրը

Այժմ Կատարողը պատասխանատու կառավարման առաջադրանքը ի կատարումն, թեմա լողավազան եւ հերթ. Եթե լողավազան ունի ավելի քիչ է, քան իր կազմաձեւված շարք նվազագույն թելերով, նոր թեմաները կստեղծվեն կարգավորել հերթում խնդիրները, մինչեւ որ սահմանը, որը հասել է կազմաձեւված արժեքի. Եթե թիվն ավելի բարձր է, քան կազմաձեվվում նվազագույնի, ապա լողավազան չի սկսել որեւէ այլ թեմաները. Փոխարեն, խնդիրն այն հերթում մինչեւ թեմա ազատվում է մշակել խնդրանքը. Եթե հերթ լի, ապա նոր թեմա, որը սկսել է կարգավորել այն.

Անջատում Կատարողը

Դադարեցումը իրականացվում է վկայակոչում է անջատում () մեթոդ. Դուք կարող եք ընտրել է դադարեցնել այն gracefully, կամ կտրուկ.