Hogyan lehet megvalósítani a hívható interfészt Java-ban

A Java többszálas programjai kiterjedt használatról tanúskodnak Hívható és jövőbeli. A szálak és a többszálas szálak előfeltétele ismeretében az olvasók jobban meg tudják fogni a cikkben szereplő vitát. Mivel ebben a cikkben elmagyarázom a Java hívható felületét.

• Összefoglalás a szálakról
• Mi a hívható felület a Java-ban
• Hívható interfész visszaküldése
• A hívható és jövőbeli osztály jellemzői
• Hívható és futható osztályok összehasonlítása

Összefoglalás a szálakról

Engedje meg azonban, hogy röviden bemutassam a szálak fogalmát. A szál a végrehajtás külön útja, abban az esetben, ha ismétlődő feladatot kell végrehajtania, a munka több feladatra bontható és szálakhoz rendelhető. Több menetnem más, mint több szál hozzárendelése különböző feladatok párhuzamos végrehajtásához, az eredmény gyors elérése érdekében.

Mi a hívható felület a Java-ban

A Java 5 esetében a „java.util.concurrent” osztály került bevezetésre. Ezt a hívható felületet a Runnable felülethez hasonlónak tűnő egyidejűségi csomagon keresztül hozták be. Bármely tárgyat visszaadhat, és kivételt képes dobni. A Java hívható felület a Generics alkalmazást használja, így bármilyen típusú objektum visszaadható. Az Executor Framework egy subm () metódust ad a Callable implementációk futtatására egy szálkészletben. A valóságban a Java Executor Framework ragaszkodik a WorkerThread mintákhoz.

Egy szálkészletben a felhasználók az Executors.newFixedThreadPool (10) metódus használatával indíthatnak szálakat, és ennek megfelelően feladatot nyújthatnak be neki. Egy futható szál célpontjaként működik, és egy public void run () metódust kötelezően végrehajtanak a feladat meghatározásához. Ezt a szálkészlet szálai hajtják végre. A szálak rendelkezésre állása alapján a készletben az Executor Framework munkát (futtatható célt) rendel a szálakhoz.Ha az összes szál van használatban, a feladatot le kell állítani. Miután a szál befejezte az egyik feladatot, ezután elérhető készletként visszatér a készletbe, amely készen áll a jövőbeli feladatok elfogadására. A Callable hasonló a Runnable-hoz, és bármilyen típusú objektumot visszaadhat, ha eredményt vagy állapotot szeretnénk kapni a feladattól.

Hívható interfész visszaküldése

A Java Callable a java.util.concurrent fájlt adja vissza. A Java Future egy Cancel () metódust kínál a kapcsolódó Hívható feladat kiküszöbölésére. Ez a get () metódus túlterhelt változata, ahol megadhat egy bizonyos időt az eredmény megvárására. Hasznos elkerülni az aktuális szálat, amely hosszabb ideig blokkolható lehet. Ne feledje, hogy a get metódus szinkron metódus, és amíg a hívható befejezi a feladatát, és vissza nem ad egy értéket, addig várnia kell egy hívhatóra.

Vannak „isDone ()” és „isCancelled ()” módszerek is, amelyek lekérik a társított hívható feladat aktuális állapotát. Vizsgáljuk meg azt a példát, ahol meg kell találni az összes szám egy és 100 közötti összegét. Az 1-től 100-ig hurkolhatunk egymás után, végül hozzáadva őket. Egy másik lehetőség a megosztottság és a hódítás. Ebben a módszerben a számokat úgy csoportosíthatjuk, hogy mindegyik csoportnak pontosan két eleme legyen. Végül hozzárendelhetjük azt a csoportot egy szálkészlethez. Ezért minden szál párhuzamosan visszaad egy részösszeget, majd összegyűjti ezeket a részösszegeket, és összeadja őket az egész összeg megszerzéséhez.

hogyan lehet befejezni a java programot

A hívható és jövőbeli osztály jellemzői

• A hívható osztály egy SAM típusú interfész, ezért megvalósítható a lambda kifejezésben.

• A hívható osztálynak csak egy „call ()” módszere van, amely az aszinkron végrehajtáshoz szükséges összes kódot tartalmazza.

• Futható interfészkörnyezetben nem volt lehetőség a számítás vagy a dobás ellenőrzött kivétel eredményének visszaadására. Míg a Callable értéket ad vissza és bejelöli az engedélyezett kivételt.

  véletlenszerű karakterláncot generál a java-ban

• A Future osztály Get () metódusa használható az eredmények lekérésére, miután a számítás befejeződött. A felhasználók a done () módszerrel is ellenőrizhetik, hogy a számítás befejeződött-e vagy sem.

• A számítás törlése a future.cancel () metódus használatával szintén haszont jelent bizonyos alkalmazásokban.

• A Get () -t blokkoló hívásnak hívják, és addig folytatja a blokkolást, amíg a számítás be nem fejeződik.

Hívható és futható osztályok összehasonlítása

Az alábbiakban bemutatunk egy egyszerű példát egy Java meghívható osztályra, ahol a kód visszaadja az adott szál nevét, amely egy másodperc után végrehajtja a feladatot. Itt a kivonó keretrendszer segítségével 100 feladatot hajtunk végre a Java Future programmal párhuzamosan a beküldött feladatok eredményéhez. Az első részlet a kimenet, az alábbi pedig a kódot jelenti.

com.journaldev.threads import java.util.ArrayList import java.util.Date import java.util.List import java.util.concurrent.Callable import java.util.concurrent.ExecutionException import java.util.concurrent.ExecutorService import java .util.concurrent.Vezetők importálják a java.util.concurrent.Future nyilvános osztályú MyCallable megvalósítja a Callable {@Orride public String call () dobást Kivétel {Thread.sleep (1000) // visszaadja a hívható feladatot végrehajtó szál nevét. () .getName ()} public static void main (Karakterláncok [] objektum társítva a Hívható listáhozlist = new ArrayList() // MyCallable példány létrehozása Callable callable = new MyCallable () a (int i = 0 i<100 i++){ //submit Callable tasks to be executed by thread pool Future future = executor.submit(callable) //add Future to the list, we can get return value using Future list.add(future) } for(Future fut : list){ try { //print the return value of Future, notice the output delay in console // because Future.get() waits for task to get completed System.out.println(new Date()+ '::'+fut.get()) } catch (InterruptedException | ExecutionException e) { e.printStackTrace() } } //shut down the executor service now executor.shutdown() } } 

Az Executor Services leállítása

A döntő és fontos szempont, amelyet sok fejlesztő hiányol, az ExecutorService leállítása. Az ExecutorService létfontosságú és további szálelemekkel jön létre. Ne feledje, hogy a JVM csak akkor áll le, ha az összes nem démonos szál le van állítva. Így a végrehajtó szolgáltatás egyszerű leállítása megakadályozza a JVM leállását.

Annak érdekében, hogy elmondjuk a végrehajtó szolgáltatásnak, hogy nincs szükség a szálak futtatására, le kell állítanunk a szolgáltatást.

A leállításra háromféleképpen lehet hivatkozni:

különbség a túlterhelés és az felülbírálás között a java-ban

• érvénytelen leállítás () - Ez egy rendezett leállítást kezdeményez, amelyben a korábban benyújtott feladatokat végrehajtják, de új feladatokat nem fogadnak el.
• List shutdownNow () - Megpróbálja leállítani az összes aktívan végrehajtott feladatot, leállítja a függőben lévő feladatok feldolgozását, és visszaküldi a végrehajtásra váró feladatok listáját is.
• void awaitTermination () - Ez addig blokkol, amíg az összes feladat nem fejeződik be egy leállítási kérés után, vagy az időkorlát bekövetkezik. Blokkolja az aktuális szál megszakadását is. Minden attól függ, melyik feladat jön előbb.

Ezzel a Java-ban a Callable Interface végére értünk. Remélem, megértette a Java jövőbeli és hívható felületét.

Nézze meg a az Edureka, egy megbízható online tanulási vállalat, amelynek több mint 250 000 elégedett tanulóval rendelkező hálózata elterjedt az egész világon. Az Edureka Java J2EE és SOA képzési és tanúsítási tanfolyamát olyan hallgatók és szakemberek számára tervezték, akik Java fejlesztők szeretnének lenni.

Van egy kérdésünk? Kérjük, említse meg ennek a „Callable Interface in Java” blognak a megjegyzés rovatában, és a lehető leghamarabb kapcsolatba lépünk Önnel.