Hvordan implementere Callable Interface i Java

Java multithreading-programmer er vitne til bruken av omfattende Callable og Future. Under den forutsette kunnskapen om tråder og multi-threading, vil leserne være bedre i stand til å forstå diskusjonen i denne artikkelen. Som jeg skal forklare Callable Interface i Java i denne artikkelen.

• Sammendrag på tråder
• Hva er Callable Interface i Java
• Returnering av Callable Interface
• Funksjoner i Callable og Future Class
• Sammenligning av kallbare og kjørbare klasser

Sammendrag på tråder

Men la meg bare gi en kort introduksjon til begrepet tråder. En tråd er en egen utførelsesvei, i tilfelle du trenger å utføre en repeterende oppgave, kan arbeidet deles inn i flere oppgaver og tilordne dem til tråder. Multi-threadinger ikke annet enn å tildele flere tråder for å utføre forskjellige oppgaver parallelt for å få resultatet raskt.

hvordan du finner datatypen i python

Hva er Callable Interface i Java

For Java 5 ble klassen “java.util.concurrent” introdusert. Dette kallbare grensesnittet ble hentet inn via samtidighetspakken som lignet Runnable-grensesnittet. Det kan også returnere ethvert objekt og kan kaste et unntak. Et Java Callable-grensesnitt bruker Generics, og gjør det mulig å returnere alle typer objekter. Executor Framework gir en submit () -metode for å utføre Callable-implementeringer i en gruppe tråder. I virkeligheten overholder Java Executor Framework WorkerThread-mønstrene.

I en trådpool kan brukere starte tråder ved å bruke metoden Executors.newFixedThreadPool (10) og deretter sende en oppgave til den. En kjørbar fungerer som målet for en tråd, og en offentlig ugyldig run () -metode er obligatorisk implementert for å definere oppgaven. Dette vil bli utført av tråder i trådgruppen. Basert på tilgjengeligheten av trådene i bassenget, tildeler Executor Framework arbeid (kjørbart mål) til tråder.Hvis alle tråder er i bruk, må oppgaven stoppes. Etter at tråden har fullført en oppgave, går den tilbake til bassenget som en tilgjengelig tråd, som er klar til å godta fremtidige oppgaver. Callable ligner Runnable og kan returnere alle typer objekter når vi ønsker å få et resultat eller status fra oppgaven.

Returnering av Callable Interface

Java Callable returnerer java.util.concurrent. Java Future tilbyr en Cancel () -metode for å eliminere den tilknyttede Callable-oppgaven. Dette er en overbelastet versjon av get () -metoden, der man kan spesifisere en viss tid å vente på resultatet. Det er nyttig å unngå en gjeldende tråd, som kan være blokkert over lengre tid. Husk at get-metoden er en synkron metode, og til den callable er ferdig med oppgaven og returnerer en verdi, må den vente på en callable.

Det er også 'isDone ()' og 'isCancelled ()' -metoder for å hente gjeldende status for en tilknyttet Callable-oppgave. Tenk på eksemplet der en sum av alle tall fra ett til 100 må bli funnet. Vi kan løkke 1 til 100 sekvensielt og legge dem til slutt. En annen mulighet er ved å dele og erobre. I denne metoden kan vi gruppere tallene på en måte slik at hver gruppe har nøyaktig to elementer. Til slutt kan vi tilordne den gruppen til en gruppe tråder. Derfor returnerer hver tråd en delsum parallelt og deretter samler de delsummen og legger dem til for å få hele summen.

Funksjoner i Callable og Future Class

• Callable klasse er et SAM-grensesnitt, og kan derfor implementeres i lambda-uttrykket.

• Den kallbare klassen har bare en metode 'call ()' som inneholder all koden som trengs for å utføre asynkront.

• I et kjørbart grensesnittmiljø var det ingen mulighet til å returnere resultatet av beregningen eller kaste kontrollert unntak. Mens det med Callable er å returnere en verdi og kaste et merket unntak er tilgjengelig.

• Get () -metoden i Future-klassen kan brukes til å hente resultater når beregningen er gjort. Brukere kan også sjekke om beregningen er ferdig eller ikke ved hjelp av gjort () -metoden.

  anvendelser av stor dataanalyse

• Avbryte beregningen ved hjelp av future.cancel () -metoden er også en velsignelse i noen applikasjoner.

• Get () kalles et blokkeringsanrop, og det fortsetter å blokkere til beregningen er fullført.

Sammenligning av kallbare og kjørbare klasser

Nedenfor er et enkelt eksempel på en Java-kallbar klasse implementert der koden returnerer navnet på den spesifikke tråden, som utfører oppgaven etter ett sekund. Her bruker vi extractor-rammeverket til å utføre 100 oppgaver parallelt med Java Future til resultatet av de innsendte oppgavene. Den første utdraget er utdataene og under representerer koden.

hvordan snu streng i python

pakke 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 importerer java.util.concurrent.Future public class MyCallable implementerer Callable {@Override public String call () kaster Unntak {Thread.sleep (1000) // returnerer trådnavnet som utfører denne kallbare oppgaven, 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) // lag en liste for å holde fremtiden objekt tilknyttet Callable Listliste = ny ArrayList() // Opprett MyCallable-forekomst Callable callable = new MyCallable () for (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() } } 

Legge ned eksekutortjenester

Det avgjørende og viktige aspektet som mange utviklere savner, er å stenge ExecutorService. ExecutorService er viktig og er opprettet med flere trådelementer. Husk at JVM stopper bare når alle ikke-demon-tråder stoppes. Dermed hindrer bare JVM å stoppe eksekutortjenesten.

For å fortelle eksekutortjenesten at det ikke er behov for at trådene kjøres, bør vi slå av tjenesten.

Det er tre måter å påberope nedleggelse på:

• ugyldig nedleggelse () - Dette initierer en ordnet nedstengning der tidligere innsendte oppgaver utføres, men ingen nye oppgaver aksepteres.
• List shutdownNow () - Den prøver å stoppe alle aktivt utførende oppgaver, stopper behandlingen av ventende oppgaver, og returnerer også en liste over oppgavene som ventet på utførelse.
• void awaitTermination () - Dette fortsetter å blokkere til alle oppgaver er ferdig utført etter en avslutningsforespørsel, eller tidsavbrudd oppstår. Det blokkeres også når den gjeldende tråden blir avbrutt. Alt avhenger av hvilken oppgave som kommer først.

Med dette kommer vi til slutten av Callable Interface i Java-artikkelen. Jeg håper du har forståelse for Future and Callable Interface i Java.

Sjekk ut av Edureka, et pålitelig online læringsfirma med et nettverk med mer enn 250 000 fornøyde elever spredt over hele verden. Edurekas Java J2EE- og SOA-opplæring og sertifiseringskurs er designet for studenter og fagpersoner som ønsker å være Java-utvikler.

Har du spørsmål til oss? Vennligst nevn det i kommentarfeltet i denne 'Callable Interface in Java' -bloggen, så kommer vi tilbake til deg så snart som mulig.