Hoe een oproepbare interface in Java te implementeren

Dit artikel biedt u gedetailleerde en uitgebreide kennis van het implementeren van Callable Interface in Java met voorbeelden.

Java-multithreading-programma's zijn getuige van het gebruik van uitgebreide Oproepbaar en toekomstig. Onder de vereiste kennis van threads en multi-threading zullen lezers de discussie in dit artikel beter kunnen begrijpen. Zoals ik in dit artikel Callable Interface in Java zal uitleggen.

Samenvatting op Threads

Laat me echter een korte inleiding geven op het concept van threads. Een thread is een apart uitvoeringspad, voor het geval u een repetitieve taak moet uitvoeren, kan het werk worden opgesplitst in meerdere taken en deze aan threads toewijzen. Multi-threadingis niets anders dan het toewijzen van meerdere threads om verschillende taken parallel uit te voeren om snel het resultaat te krijgen.



Wat is een oproepbare interface in Java

Voor Java 5 werd de klasse “java.util.concurrent” geïntroduceerd. Deze oproepbare interface werd ingevoerd via het concurrency-pakket dat leek op de Runnable-interface. Het kan ook elk object retourneren en kan een uitzondering genereren. Een Java-oproepbare interface gebruikt Generics, waardoor het mogelijk wordt om elk type object te retourneren. Het Executor Framework geeft een submit () methode om Callable implementaties uit te voeren in een pool van threads. In werkelijkheid past het Java Executor Framework zich aan de WorkerThread-patronen.

java-interfaceIn een threadpool kunnen gebruikers threads starten met behulp van de Executors.newFixedThreadPool (10) -methode en dienovereenkomstig een taak eraan verzenden. Een uitvoerbare fungeert als het doelwit van een thread en een public void run () - methode wordt verplicht geïmplementeerd om de taak te definiëren. Dit wordt uitgevoerd door threads in de threadpool. Op basis van de beschikbaarheid van de threads in de pool, wijst het Executor Framework werk (uitvoerbaar doel) toe aan threads.Als alle threads in gebruik zijn, moet de taak worden gestopt. Nadat de thread een taak heeft voltooid, keert deze terug naar de pool als een beschikbare thread, die klaar is om toekomstige taken te accepteren. Callable is vergelijkbaar met Runnable en kan elk type object retourneren als we een resultaat of status van de taak willen krijgen.

Teruggave van oproepbare interface

Java Callable retourneert java.util.concurrent. Java Future biedt een methode cancel () om de bijbehorende Callable-taak te elimineren. Dit is een overbelaste versie van de get () - methode, waar men een bepaalde tijd kan specificeren om op het resultaat te wachten. Het is handig om een ​​huidige thread te vermijden, deze kan voor een langere periode geblokkeerd zijn. Onthoud dat de get-methode een synchrone methode is en totdat de aanroepbare zijn taak heeft voltooid en een waarde retourneert, zal het moeten wachten op een aanroepbare.

Er zijn ook 'isDone ()' en 'isCancelled ()' methoden om de huidige status van een bijbehorende oproepbare taak op te halen. Beschouw het voorbeeld waarin een som van alle getallen van één tot 100 moet worden gevonden. We kunnen 1 tot 100 opeenvolgend herhalen en ze uiteindelijk toevoegen. Een andere mogelijkheid is door te verdelen en te overwinnen. Bij deze methode kunnen we de getallen zo groeperen dat elke groep precies twee elementen heeft. Ten slotte kunnen we die groep toewijzen aan een pool met threads. Daarom retourneert elke thread een gedeeltelijke som parallel en verzamelt vervolgens die gedeeltelijke sommen en telt ze op om de hele som te krijgen.

Kenmerken van opvraagbare en toekomstige klasse

  • Oproepbare klasse is een SAM-type interface en kan daarom worden geïmplementeerd in de lambda-expressie.

  • De aanroepbare klasse heeft slechts één methode 'call ()' die alle code bevat die nodig is om asynchroon uit te voeren.

    c ++ sorteeralgoritme
  • In een uitvoerbare interface-omgeving was er geen mogelijkheid om het resultaat van de berekening of de throw-check-uitzondering te retourneren. Terwijl bij Callable het retourneren van een waarde en het gooien van een gecontroleerde uitzondering beschikbaar is.

  • De methode Get () van de Future-klasse kan worden gebruikt om resultaten op te halen zodra de berekening is voltooid. Gebruikers kunnen ook controleren of de berekening is voltooid of niet door de methode done () te gebruiken.

  • Het annuleren van de berekening met de methode future.cancel () is in sommige toepassingen ook een zegen.

  • Get () wordt een blokkerende oproep genoemd en blijft blokkeren totdat de berekening is voltooid.

Vergelijking van oproepbare en uitvoerbare klassen

Oproepbaar Uitvoerbaar
Het maakt deel uit van de “ java.util.concurrent ' pakket sinds Java 1.5Het maakt deel uit van het pakket java.lang sinds Java 1.0
Een geparametriseerde interface, zoals CallableEen interface zonder parameters
Kan een aangevinkte uitzondering werpenHet kan geen gecontroleerde uitzondering genereren
Het bevat een enkele methode, call (), die Type V retourneert, dit is hetzelfde als de gedefinieerde interfaceparameter 'Type'Hier bevat het een enkele methode, genaamd run (), die ongeldig retourneert

Hieronder ziet u een eenvoudig voorbeeld van een Java-aanroepbare klasse die is geïmplementeerd waarbij de code de naam van de specifieke thread retourneert, die de taak na één seconde uitvoert. Hier gebruiken we het extractor-framework om 100 taken parallel met Java Future uit te voeren naar het resultaat van de ingediende taken. Het eerste fragment is de uitvoer en het onderstaande geeft de code weer.

pakket 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.Executors import java.util.concurrent.Future public class MyCallable implementeert Callable {@Override public String call () throws Exception {Thread.sleep (1000) // retourneer de threadnaam die deze oproepbare taak uitvoert, retourneer Thread.currentThread () .getName ()} public static void main (String args []) {// Haal ExecutorService op van Executors utility class, thread pool grootte is 10 ExecutorService executor = Executors.newFixedThreadPool (10) // maak een lijst om de toekomst vast te houden object dat is gekoppeld aan opvraagbare lijstlist = nieuwe ArrayList() // Create MyCallable instance Callable callable = new MyCallable () voor (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() } } 

Executor Services afsluiten

Het cruciale en belangrijke aspect dat veel ontwikkelaars missen, is het afsluiten van de ExecutorService. De ExecutorService is essentieel en wordt gemaakt met extra thread-elementen. Houd er rekening mee dat de JVM alleen stopt als alle niet-daemon-threads zijn gestopt. Dus door simpelweg de executor-service af te sluiten, wordt voorkomen dat de JVM stopt.

Om de executor-service te vertellen dat het niet nodig is dat de threads worden uitgevoerd, moeten we de service afsluiten.

Er zijn drie manieren om afsluiten aan te roepen:

  • leegte afsluiten () - Dit initieert een ordelijke afsluiting waarin eerder ingediende taken worden uitgevoerd, maar geen nieuwe taken worden geaccepteerd.
  • Lijst shutdownNow () - Het probeert alle actief uitvoerende taken te stoppen, stopt de verwerking van lopende taken en retourneert ook een lijst met taken die op uitvoering wachtten.
  • leegte awaitTermination () - Dit blijft blokkeren totdat alle taken zijn voltooid na een afsluitverzoek, of de time-out optreedt. Het blokkeert ook wanneer de huidige thread wordt onderbroken. Alles hangt af van welke taak het eerst komt.

Hiermee komen we aan het einde van het Callable Interface in Java-artikel. Ik hoop dat je begrip hebt van Future and Callable Interface in Java.

Bekijk de door Edureka, een vertrouwd online leerbedrijf met een netwerk van meer dan 250.000 tevreden leerlingen verspreid over de hele wereld. De training- en certificeringcursus Java J2EE en SOA van Edureka is bedoeld voor studenten en professionals die Java-ontwikkelaar willen worden.

Heeft u een vraag voor ons? Vermeld het in de commentarensectie van deze 'Oproepbare interface in Java' -blog en we nemen zo snel mogelijk contact met u op.