Samkeppni í Java, hluti 1 – Inngangur

Almennt er hefðbundin forritunaraðferð röðbundin. Allt í forriti gerist skref fyrir skref.
En í raun er hliðstæðan hvernig heiminum öllum er stjórnað – það er hæfileikinn til að sinna fleiri en einu verkefni samtímis.

Þráður vs. ferli

Til að ræða svo háþróuð efni sem samtímakönnun í Java Eða varðandi margþráðavinnslu, verðum við að semja um nokkrar sameiginlegar skilgreiningar til að vera viss um að við séum á sama máli.

Skulum byrja á grunnatriðunum. Í heimi án tímaröðunar höfum við tvær tegundir samhliða fulltrúa: ferla og
Þræðir. Ferli er einstaklingur forrits sem er í gangi. Venjulega er það einangrað frá öðrum ferlum.
Stýrikerfið ber ábyrgð á úthlutun auðlinda til hvers ferlis. Ennfremur starfar það sem hljómsveitarstjóri sem
skipuleggur og stýrir þeim.

Þráður er tegund ferlis en á lægra stigi, þess vegna er hann einnig kallaður léttur þráður. Margir þræðir geta keyrt í einum
ferli. Hér starfar forritið sem áætlunarstjóri og stýringaraðili þráða. Á þennan hátt virðast einstök forrit gera
mörg verkefni samtímis.

Grunnmunurinn á þráðum og ferlum er einangrunarstigið. Ferlið hefur sitt eigið sett af
auðlindir, á meðan þráðurinn deilir gögn með öðrum þráðum. Það kann að virðast vera villuhneigð nálgun og það er það reyndar. Fyrir
Nú skulum við ekki einbeita okkur að því, því það er utan umfangs þessa greinar.

Ferlar, þræðir – allt í lagi… En hvað er samhliða vinnsla nákvæmlega? Samhliða vinnsla þýðir að þú getir keyrt mörg verkefni samtímis
tími. Það þýðir ekki að þessar aðgerðir þurfi að keyra samtímis – það er það sem samhliða vinnsla er. Samkeppni í Java gerir það heldur ekki
krefst þess að þú hafir marga örgjörva eða jafnvel marga kjarna. Þetta má ná fram í umhverfi með einum kjarna með því að nýta
samhengi-skipting.

Hugtak tengt samhliða vinnslu er fjölþráða vinnsla. Þetta er eiginleiki forrita sem gerir þeim kleift að framkvæma mörg verkefni samtímis. Ekki öll forrit nota þessa nálgun en þau sem gera það kallast fjölþráða.

Við erum næstum tilbúin að hefja, bara ein skilgreining í viðbót. Asynchróni þýðir að forrit framkvæmir óblokkandi aðgerðir.
Það byrjar verkefni og heldur síðan áfram með önnur verkefni á meðan það bíður eftir svari. Þegar það fær svarið getur það react að því.

Allt þetta djass

Að sjálfgefinni stillingu, hver Java-forrit keyrir í einu ferli. Í því ferli er ein þráð sem tengist aðal() aðferð
umsókn. Hins vegar, eins og áður hefur verið nefnt, er hægt að nýta sér kerfi margra þráða innan eins
forrit.

Keyranlegt

Þráður er Java flokkur þar sem töfrarnir eiga sér stað. Þetta er hlutagerð af fyrrnefndu þræði. Til
búa til þitt eigið þráð, þú getur stækkað það Þráður class. Hins vegar er þetta ekki ráðlagður aðferðarháttur. Þræðir ætti að vera notað sem vélbúnaður sem keyrir verkefnið. Verkefni eru hlutar af kóði sem við viljum keyra í samhliða ham. Við getum skilgreint þau með því að nota Keyranlegt viðmót.

En nóg um kenningar, skulum við láta kóðann tala.

Vandamál

Gerum ráð fyrir að við höfum nokkra fylki af tölum. Fyrir hvert fylki viljum við vita summu talnanna í fylkinu. Skulum
Ímyndaðu þér að það séu margar slíkar fylkingar og hver þeirra sé tiltölulega stór. Í slíkum aðstæðum viljum við nýta samhliða vinnslu og leggja saman hverja fylkingu sem sitt verkefni.

int[] a1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int[] a2 = {10, 10, 10, 10, 10, 10, 10, 10};
int[] a3 = {3, 4, 3, 4, 3, 4, 2, 1, 3, 7};

Runnable task1 = () -> {
    int sum = Arrays.stream(a1).sum();
    System.out.println("1. Summan er: " + sum);
};

Runnable task2 = () -> {
    int sum = Arrays.stream(a2).sum();
    System.out.println("2. Summan er: " + sum);
};

Runnable task3 = () -> {
    int sum = Arrays.stream(a3).sum();
    System.out.println("3. Summan er: " + sum);
};

new Thread(task1).start();
new Thread(task2).start();
new Thread(task3).start();

Eins og sjá má í kóðanum hér að ofan Keyranlegt er virkt viðmót. Það inniheldur eina abstrakta aðferð. keyra()
án rökum. The Keyranlegt Íhlutaskil skulu vera innleidd af hvaða flokki sem er, þar sem ætlast er til að eintök hans séu
framkvæmt af þræði.

Þegar þú hefur skilgreint verkefni geturðu búið til þráð til að keyra það. Þetta er hægt að gera með nýja þráðinn() smíðara sem
tekur Keyranlegt sem rökstuðning sinn.

Síðasta skrefið er að hafta() nýlega búinn þráður. Í forritaskil Það eru líka keyra() aðferðir í Keyranlegt og í
Þráður. Hins vegar er það ekki leið til að nýta samhliða vinnslu í Java. Beinn kall í hvern og einn af þessum aðferðum leiðir til
að framkvæma verkefnið í sama þræðinum aðal() aðferðir keyra.

Þráðapóllar og framkvæmdarar

Þegar verkefnin eru mörg er ekki góð hugmynd að búa til aðskilda þráð fyrir hvert þeirra. Að búa til Þráður er
Þetta er umfangsmikil aðgerð og mun betra er að endurnýta núverandi þræði en að búa til nýja.

Þegar forrit býr til marga skammtíma þræði er betra að nota þráðapott. Þráðapotturinn inniheldur fjölda
tilbúin til keyrslu en nú ekki virk þræðir. Gefa Keyranlegt að sundlauginni veldur því að einn af þráðunum kallar
keyra() aðferð gefin Keyranlegt. Eftir að verkefni er lokið er þráðurinn enn til staðar og í biðham.

Ok, þú skilur það – kjósaðu þráðapottinn frekar en að búa til þræði handvirkt. En hvernig geturðu nýtt þráðapotta? The Skiptastjórar
class hefur fjölda statískra verksmiðjuaðferða til að búa til þráðalaugar. Til dæmis nýrCachedThredPool() býr til
sjóður þar sem nýjar þræðir eru búnar til eftir þörfum og auðar þræðir eru geymdar í 60 sekúndur. Í mótsögn,
nýrFöstÞráðaSjóður() Inniheldur fast sett af þráðum, þar sem auðir þræðir eru geymdir óákveðið.

Sjáum hvernig þetta gæti virkað í dæminu okkar. Nú þurfum við ekki að búa til þræði handvirkt. Í staðinn verðum við að búa til
Viðskiptaþjónusta sem býður upp á þráðasafn. Síðan getum við úthlutað verkefnum til þess. Síðasta skrefið er að loka þræðinum.
pool til að forðast minnisleka. Restin af fyrri kóðanum er óbreytt.

ExecutorService executor = Executors.newCachedThreadPool();

executor.submit(task1);
executor.submit(task2);
executor.submit(task3);

executor.shutdown();

Kallanlegur

Keyranlegt Virðist vera snjall háttur til að búa til samhliða verkefni en það hefur einn stóran galla. Það getur ekki skilað neinu
gildi. Enn fremur getum við ekki ákvarðað hvort verkefni sé lokið eða ekki. Við vitum heldur ekki hvort því hafi verið lokið.
venjulega eða undantekningarlaust. Lausnin við þessum kvillum er Kallanlegur.

Kallanlegur er svipað og Keyranlegt Á einhvern hátt umlykur það einnig ósamstilltar aðgerðir. Helsti munurinn er sá að það getur
Skila gildi. Skilagildi getur verið af hvaða (ekki frumstæðum) gerð sem er, þar sem Kallanlegur interface er breytutýpa.
Kallanlegur er virkt viðmót sem hefur kalla() aðferð sem getur kastað Undantekning.

Nú skulum við sjá hvernig við getum nýtt okkur Kallanlegur í fylkismálinu okkar.

int[] a1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int[] a2 = {10, 10, 10, 10, 10, 10, 10, 10};
int[] a3 = {3, 4, 3, 4, 3, 4, 2, 1, 3, 7};

Callable task1 = () -> Arrays.stream(a1).sum();
Callable task2 = () -> Arrays.stream(a2).sum();
Callable task3 = () -> Arrays.stream(a3).sum();

ExecutorService executor = Executors.newCachedThreadPool();
Future future1 = executor.submit(task1);
Future future2 = executor.submit(task2);
Future future3 = executor.submit(task3);

System.out.println("1. Summan er: " + future1.get());
System.out.println("2. Summan er: " + future2.get());
System.out.println("3. Summan er: " + future3.get());

executor.shutdown();

Allt í lagi, við sjáum hvernig Kallanlegur er búið til og síðan sent til Viðskiptaþjónusta. En hvað í ósköpunum er Framtíð?
Framtíð starfar sem brú milli þráða. Summa hvers fylkis er framleidd í aðskildum þræði og við þurfum leið til að
Fáðu þessar niðurstöður til baka til aðal().

Til að sækja niðurstöðuna frá Framtíð Við þurfum að hringja fá() aðferð. Hér geta tvær hlutir gerst. Í fyrsta lagi,
niðurstaða útreiknings sem framkvæmdur var af Kallanlegur er tiltækt. Þá fáum við það strax. Í öðru lagi er niðurstaðan ekki
Ertu tilbúinn ennþá? Annars fá() aðferðin mun stöðva vinnuna þar til niðurstaðan liggur fyrir.

Reiknanleg framtíð

Vandamálið með Framtíð er að það virkar í ‘push-paradígunni’. Þegar notað er Framtíð Þú verður að vera eins og yfirmaður sem
spyr stöðugt: ‘Er verkefnið búið? Er það tilbúið?’ þar til það skilar niðurstöðu. Að starfa undir stöðugum þrýstingi er
Dýrt. Mun betri nálgun væri að panta Framtíð Hvað á að gera þegar það hefur lokið verkefni sínu. Því miður,
Framtíð get ekki gert það en Reiknanleg framtíð getur.

Reiknanleg framtíð starfar í ‘pull-paradígu’. Við getum sagt því hvað á að gera við niðurstöðuna þegar það hefur lokið verkefnum sínum. Það
er dæmi um ósamstilltan nálgun.

Reiknanleg framtíð virkar fullkomlega með Keyranlegt en ekki með Kallanlegur. Í staðinn er hægt að afhenda verkefni til
Reiknanleg framtíð í formi af Birgir.

Skoðum hvernig hið fyrrnefnda tengist vandamálinu okkar.

int[] a1 = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
int[] a2 = {10, 10, 10, 10, 10, 10, 10, 10};
int[] a3 = {3, 4, 3, 4, 3, 4, 2, 1, 3, 7};

CompletableFuture.supplyAsync(() -> Arrays.stream(a1).sum())
 .thenAccept(System.out::println);

CompletableFuture.supplyAsync(() -> Arrays.stream(a2).sum())
 .thenAccept(System.out::println);

CompletableFuture.supplyAsync(() -> Arrays.stream(a3).sum())
 .thenAccept(System.out::println);

Það fyrsta sem tekur þig á óvart er hversu miklu styttra þetta lausn er. Að auki lítur hún snyrtileg og vel skipulögð út.

Verkefni til Framtíð sem hægt er að ljúka getur verið veitt af Birgðasamstillt() aðferð sem tekur Birgir eða með keyraAsynchrónt() að
tekur Keyranlegt. Callback – kóðabrot sem á að keyra þegar verkefni lýkur – er skilgreint af þá samþykkja()
aðferð.

Ályktanir

Java veitir margar mismunandi nálganir að samhliða vinnslu. Í þessari grein snerumst við varla um efnið.

Engu að síður fórum við yfir grunnatriðin í Þráður, Keyranlegt, Kallanlegur, og Kallanlegt framtíð sem er góð spurning
fyrir frekari rannsókn á umfjöllunarefninu.