Tá an Creat Seiceadóir tugtha isteach i Java 1.5 agus tá sé ina chuid de phacáiste java.util.concurrent. Tá an creat Seiceadóir ar astarraingt os cionn a chur chun feidhme iarbhír na multithreading java. Tá sé a úsáidtear le haghaidh a chaighdeánú agairt, sceidealú, fhorghníomhú agus rialú cúraimí asynchronous de réir sraith de pholasaithe fhorghníomhú sainithe le linn a chruthú ar an cruthaitheoir.
Roimh java 1.5, Rinneadh na hiarratais multithreading cruthaíodh ag baint úsáide as grúpa snáithe , linn snámha snáithe nó linn snámha snáithe saincheaptha. Anois tá an rialú ar gach snáithe le déanamh ag an Ríomhchláraitheoir a choinneáil i gcuimhne na pointí seo a leanas
● Synchronization
● Glasáil
● Fógra
● glas Dead
Agus go leor eile a thagann chun cinn as an gceanglas iarratais. Roinnt ama tá sé an-deacair a rialú ar iarratais multithreading mar go bhfuil na hiompraíochtaí na snáitheanna ag brath ar an gcomhshaol ina bhfuil an t-iarratas imscaradh agus a reáchtáil chomh maith. Mar shampla, an luas an phróiseálaí, an méid RAM, Tá tionchar díreach acu ar an iarratas multithreading an leithead banna ar fad. Mar sin, caithfidh tú a choinneáil ar na fachtóirí seo i gcuimhne roimh a chruthú ailtireacht.
Soláthraíonn creat Seiceadóir cláir i bhfeidhm il-threading le hastarraingt éasca do smaoineamh ar thascanna. In ionad ag smaoineamh i dtéarmaí na snáitheanna, Déileálann iarratas anois ach le cásanna Runnable (a bhfuil bunúsach bailiúcháin na tascanna). Agus ansin tá sé ar aghaidh chuig an Seiceadóir a phróiseáil. Síneann an comhéadan ExecutorService an comhéadan Seiceadóir saonta agus tá modhanna saolré an creat seiceadóir a bhainistiú.
Is ionann an creat Seiceadóir tascanna trí úsáid a bhaint cásanna Runnable nó Inghlaoite. Reáchtáil Runnable s () Ní Modh ais luach nó caith eisceacht a sheiceáil. Is inghlaoite leagan níos feidhmiúla sa réimse sin. Sainmhíníonn sé glao () modh a ligeann an tuairisceán ar roinnt luach ríofa is féidir a úsáid i bpróiseáil anseo. Agus throws sé freisin eisceacht más gá.
Tá an rang FutureTask a úsáidtear chun faisnéis sa todhchaí maidir le próiseáil a fháil. Is féidir le cás aicme seo wrap ceachtar Inghlaoite nó Runnable. Is féidir leat a fháil ar bhfuil drochriarachán seo mar an luach ar ais isteach () modh ar ExecutorService. Is féidir leat freisin wrap láimh do chúram i FutureTask roimh ag glaoch fhorghníomhú () modh.
Tar éis iad na céimeanna a fheidhm chun an ThreadPoolExecutor a chur i bhfeidhm.
● Tá linn snámha il / snáithe amháin a cruthaíodh.
● Tá scuaine a cruthaíodh i seilbh na tascanna go léir ach nach bhfuil na cúraimí a shanntar fóill snáitheanna as an linn snámha. Cuimsithe agus tá scuainí unbounded ar fáil.
Tá ● láimhseálaí Diúltú a úsáidtear chun déileáil leis an staid nuair nach bhfuil tascanna amháin nó níos mó ann a shannadh sa scuaine. Mar in aghaidh an pholasaí diúltú réamhshocraithe, beidh sé caith ach eisceacht runtime RejectedExecutionException, agus is féidir leis an t-iarratas a ghabháil nó a scriosadh é.
Cuirtear an méid seo sampla chun breathnú ar an timthriall saoil de chreat seiceadóir. Anseo beidh muid a phlé ach na céimeanna bhonn agus na Comhéadain bunúsacha. Tá go leor airíonna níos mó agus fo-aicmí atá ar fáil chun plé le chineál éagsúla de riachtanais iarratasóra.
Cuireann an rang seo a leanas Runnable agus beidh a cásanna a úsáid mar chúram sa chéad chuid eile de chód.
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);
}
}
Tá an rang seo a leanas a chur i bhfeidhm na tascanna seiceadóir.
import java.util.concurrent.*;
import java.util.Random;
UseExecutorService rang poiblí {
statach neamhní príomh phoiblí(Thagair Teaghrán[]) {
Random randamach = Random nua();
ExecutorService seiceadóir = Executors.newFixedThreadPool(3);
// Suim suas amanna feithimh go mbeadh a fhios nuair a múchadh
slánuimhir waitTime = 500;
le haghaidh (int i = 0; i<10; i ) {
Teaghrán ainm = “NamePrinter ” + i;
am slánuimhir = random.nextInt(1000);
waitTime = am;
Rádala Runnable = jobPrint nua(ainm, am);
System.out.println(“Nuair a chuirfear: ” + ainm + ” / ” + am);
executor.execute(rádala);
}
iarracht a dhéanamh {
Thread.sleep(waitTime);
executor.shutdown();
executor.awaitTermination
(waitTime, TimeUnit.MILLISECONDS);
} ghabháil (InterruptedException neamhaird) {
}
System.exit(0);
}
}
Cruthaigh seiceadóir
An Chéad a chruthú go bhfuil drochriarachán Seiceadóir nó ExecutorService. Tá an rang Seiceadóirí roinnt modhanna mhonarcha statach a chruthú ExecutorService. For example, newFixedThreadPool() tuairisceáin shampla ThreadPoolExecutor le scuaine initialized agus unbounded agus líon seasta de snáitheanna. Agus newCachedThreadPool () tuairisceáin shampla ThreadPoolExecutor initialized le scuaine unbounded agus uimhir unbounded na snáitheanna. Sa 2ú gcás, snáitheanna atá ann cheana féin a athúsáid mura bhfuil available.If snáithe aon saor in aisce ar fáil, Tá ceann nua a cruthaíodh agus cuirtear leis an linn snámha. Beidh snáitheanna a bhí díomhaoin ar feadh níos faide ná tréimhse Teorainn ama a bhaint go huathoibríoch as an linn snámha.
Tá sé seo le linn seasta de 15 snáitheanna.
statach seiceadóir Seiceadóir deiridh príobháideach = Executors.newFixedThreadPool(15);
Is é seo an linn snámha snáithe dtaisce
exec ExecutorService príobháideach statach = Executors.newCachedThreadPool();
Tar éis go bhfuil snáithe saincheaptha seiceadóir linn snámha. Braitheann na luachanna paraiméadar ar an ngá iarratais. Seo é an linn snámha a bhfuil croí- 5 Is féidir le snáitheanna a reáchtáil i gcomhthráth agus is é an líon uasta 10. Is é an scuaine in ann a choimeád 200 tasks. Anseo ba chóir pointe amháin a mheabhrú gur chóir an méid linn snámha a choinneáil ar taobh níos airde chun freastal ar gach cúram. Is é an teorainn ama díomhaoin choinneáil mar 5 ms.
statach seiceadóir Seiceadóir deiridh príobháideach = ThreadPoolExecutor nua(5, 10, 50000L, TimeUnit.MILLISECONDS, LinkedBlockingQueue nua(200));
Cruthaigh tascanna amháin nó níos mó agus a chur sa scuaine
Cruthaigh tascanna amháin nó níos mó a bheidh le déanamh mar gcásanna de cheachtar Runnable nó Inghlaoite.
A chur faoi bhráid an tasc chun an Seiceadóir
Tar éis a chruthú ar an ExecutorService, is gá duit chun tasc a chur faoina bráid trí úsáid a bhaint ceachtar a chur isteach () nó a fhorghníomhú () modh. Anois beidh snáithe saor as an linn snámha a thógáil go huathoibríoch ar an cúraimí ó na scuaine agus é a fhorghníomhú. Anois leis an bpróiseas ar aghaidh till na tascanna go léir atá críochnaithe as an scuaine.
Rith an tasc
Anois tá an Seiceadóir freagrach as bainistiú a fhorghníomhú an tasc ar, linn snámha snáithe agus scuaine. Má tá an linn snámha níos lú ná a líon cumraithe na snáitheanna íosta, Beidh snáitheanna nua a chruthú chun tascanna a ciúáilte láimhseáil go dtí go teorainn bainte amach leis an luach cumraithe. Má tá an uimhir níos airde ná an t-íosmhéid cumraithe, ansin ní bheidh an linn snámha tús aon snáitheanna níos. Ina áit sin, Tá an tasc ciúáilte go dtí go snáithe freed suas go dtí an iarraidh a phróiseáil. Má tá an scuaine iomlán, ansin snáithe nua a thosaigh a láimhseáil é.
Múchadh an Seiceadóir
Is é an fhoirceannadh fhorghníomhú ag invoking a múchadh () modh. Is féidir leat a roghnú chun deireadh a chur leis gracefully, nó go tobann.
Tá sé seo le post iontach ar multitasking i java
Thanks
/Jhon