Hur man implementerar Callable Interface i Java

Java multithreading-program bevittnar användningen av omfattande Callable och framtid. Under förutsättningskunskapen om trådar och multi-threading kommer läsare att bättre kunna förstå diskussionen i den här artikeln. Som jag kommer att förklara Callable Interface i Java i den här artikeln.

• Sammanfattning på trådar
• Vad är Callable Interface i Java
• Återlämnande av samtalbart gränssnitt
• Funktioner i Callable och Future Class
• Jämförelse av Callable och Runnable Classes

Sammanfattning på trådar

Men låt mig bara ge en kort introduktion till begreppet trådar. En tråd är en separat körväg, om du behöver utföra en upprepad uppgift kan arbetet delas upp i flera uppgifter och tilldela dem till trådar. Multitrådningär inget annat än att tilldela flera trådar för att utföra olika uppgifter parallellt för att få resultatet snabbt.

Vad är Callable Interface i Java

För Java 5 introducerades klassen “java.util.concurrent”. Det anropbara gränssnittet hämtades in via concurrency-paketet som såg ut som det Runnable-gränssnittet. Det kan också returnera vilket objekt som helst och kan kasta ett undantag. Ett Java Callable-gränssnitt använder Generics, vilket gör det möjligt att returnera alla typer av objekt. Executor Framework ger en submit () -metod för att utföra Callable-implementeringar i en pool av trådar. I verkligheten följer Java Executor Framework WorkerThread-mönstren.

I en trådpool kan användare initiera trådar genom att använda metoden Executors.newFixedThreadPool (10) och därmed skicka en uppgift till den. En körbar fungerar som mål för en tråd och en public void run () -metod implementeras obligatoriskt för att definiera uppgiften. Detta kommer att köras av trådar i trådpoolen. Baserat på tillgängligheten av trådarna i poolen tilldelar Executor Framework arbete (körbart mål) till trådar.Om alla trådar används måste uppgiften stoppas. När tråden har slutfört en uppgift återgår den till poolen som en tillgänglig tråd, som är redo att acceptera framtida uppgifter. Callable liknar Runnable och kan returnera alla typer av objekt när vi vill få ett resultat eller status från uppgiften.

Återlämnande av samtalbart gränssnitt

Java Callable returnerar java.util.concurrent. Java Future erbjuder en avbrytningsmetod () för att eliminera den associerade uppgiften. Detta är en överbelastad version av get () -metoden, där man kan ange en viss tid att vänta på resultatet. Det är användbart att undvika en aktuell tråd som kan blockeras under en längre period. Kom ihåg att get-metoden är en synkron metod och tills den callable avslutar sin uppgift och returnerar ett värde måste den vänta på en callable.

Det finns också 'isDone ()' och 'isCancelled ()' metoder för att hämta den aktuella statusen för en associerad Callable-uppgift. Tänk på exemplet där en summa av alla siffror från en till 100 måste hittas. Vi kan slinga 1 till 100 sekventiellt och lägga till dem äntligen. En annan möjlighet är genom att dela och erövra. I den här metoden kan vi gruppera siffrorna på ett sätt så att varje grupp har exakt två element. Slutligen kan vi tilldela den gruppen till en pool av trådar. Därför returnerar varje tråd en partiell summa parallellt och samlar sedan in de partiella summorna och lägger till dem för att få hela summan.

Funktioner i Callable och Future Class

• Callable class är ett SAM-gränssnitt och kan därför implementeras i lambdauttrycket.

• Den anropbara klassen har bara en metod 'call ()' som innehåller all kod som behövs för att köra asynkront.

• I en körbar gränssnittsmiljö fanns det ingen möjlighet att returnera resultatet av beräkningen eller kasta kontrollerat undantag. Medan Callable returnerar ett värde och kastar ett markerat undantag är tillgängligt.

  hur man vänder om sträng i python

• Get () -metoden i Future-klassen kan användas för att hämta resultat när beräkningen är klar. Användare kan också kontrollera om beräkningen är klar eller inte med hjälp av gjort () -metoden.

• Att avbryta beräkningen med hjälp av future.cancel () -metoden är också en välsignelse i vissa applikationer.

  statiskt blockexempel i java

• Get () kallas ett blockerande samtal och det fortsätter att blockera tills beräkningen är klar.

Jämförelse av Callable och Runnable Classes

Nedan följer ett enkelt exempel på en Java-kallbar klass implementerad där koden returnerar namnet på den specifika tråden, som utför uppgiften efter en sekund. Här använder vi extractor-ramverket för att utföra 100 uppgifter parallellt med Java Future till resultatet av de inlämnade uppgifterna. Det första utdraget är utdata och nedan representerar koden.

paket 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 importerar java.util.concurrent.Future public class MyCallable implementerar Callable {@Override public Strängsamtal () kastar Undantag {Thread.sleep (1000) // returnerar trådnamnet som kör denna uppringningsuppgift Thread.currentThread () .getName ()} public static void main (String args []) {// Get ExecutorService from Executors utility class, thread pool size is 10 ExecutorService executor = Executors.newFixedThreadPool (10) // skapa en lista för att hålla framtiden objekt associerat med Callable Listlista = ny ArrayList() // Skapa MyCallable-instans Callable callable = new MyCallable () för (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() } } 

Stängning av exekutörtjänster

Den viktiga och viktiga aspekt som många utvecklare saknar är att stänga av ExecutorService. ExecutorService är viktig och skapas med ytterligare trådelement. Tänk på att JVM stoppar bara när alla trådar som inte är demon stoppas. Att stänga av exekutörtjänsten hindrar alltså att JVM stoppar.

För att säga till exekutörtjänsten att det inte finns något behov av att köra trådarna bör vi stänga av tjänsten.

Det finns tre sätt att åberopa avstängning:

• ogiltig avstängning () - Detta initierar en ordnad avstängning där tidigare inlämnade uppgifter utförs, men inga nya uppgifter accepteras.
• List shutdownNow () - Den försöker stoppa alla aktivt utförande av uppgifter, stoppar behandlingen av väntande uppgifter och returnerar också en lista över de uppgifter som väntade på utförande.
• void awaitTermination () - Detta fortsätter att blockeras tills alla uppgifter har slutförts efter en avstängningsbegäran eller om timeout inträffar. Det blockeras också när den aktuella tråden avbryts. Allt beror på vilken uppgift som kommer först.

Med detta kommer vi till slutet av Callable Interface i Java-artikeln. Jag hoppas att du fick en förståelse för Future och Callable Interface i Java.

Kolla in av Edureka, ett pålitligt online-lärande företag med ett nätverk av mer än 250 000 nöjda elever spridda över hela världen. Edurekas Java J2EE- och SOA-utbildning och certifieringskurs är utformad för studenter och yrkesverksamma som vill bli Java-utvecklare.

Har du en fråga till oss? Vänligen nämna det i kommentarsektionen i denna 'Callable Interface in Java' -blogg så återkommer vi till dig så snart som möjligt.