Com implementar una interfície trucable a Java

Els programes multithreading de Java són testimonis de l’ús d’extensius Convocatòria i futur. Sota el coneixement previ dels fils i els fils múltiples, els lectors podran entendre millor el debat d’aquest article. Com explicaré la interfície trucable a Java en aquest article.

• Recapitulació sobre fils
• Què és la interfície cridable a Java
• Retorn de la interfície trucable
• Característiques de Callable i Future Class
• Comparació de classes convocables i executables

Recapitulació sobre fils

Tanmateix, deixeu-me fer una breu introducció al concepte de fils. Un fil és un camí d’execució separat, en cas que necessiteu dur a terme una tasca repetitiva, el treball es pot dividir en diverses tasques i assignar-les a fils. Multi-threadingno és altra cosa que assignar diversos fils per executar diferents tasques en paral·lel per obtenir el resultat ràpidament.

Què és la interfície cridable a Java

Per a Java 5, es va introduir la classe 'java.util.concurrent'. Aquesta interfície cridable es va introduir mitjançant el paquet de simultaneïtat que semblava similar a la interfície Runnable. També pot retornar qualsevol objecte i és capaç de llançar una excepció. Una interfície Java Callable utilitza Generics, cosa que permet retornar qualsevol tipus d'objecte. El marc executor proporciona un mètode submit () per executar implementacions cridables en un grup de fils. En realitat, el Java Executor Framework s’adhereix als patrons WorkerThread.

En una agrupació de fils, els usuaris poden iniciar fils utilitzant el mètode Executors.newFixedThreadPool (10) i, en conseqüència, enviar-li una tasca. Un runnable actua com a objectiu d’un fil i s’implementa obligatòriament un mètode public void run () per definir la tasca. Això s'executarà mitjançant fils de l'agrupació de fils. En funció de la disponibilitat dels fils a l'agrupació, l'Executor Framework assigna feina (objectiu executable) als fils.Si s’utilitzen tots els fils, s’ha d’aturar la tasca. Després que el fil completi una tasca, torna al grup com a fil disponible, que està preparat per acceptar tasques futures. Callable és similar a Runnable i pot retornar qualsevol tipus d'objecte quan vulguem obtenir un resultat o estat de la tasca.

Retorn de la interfície trucable

Java Callable retorna java.util.concurrent. Java Future ofereix un mètode cancel () per eliminar la tasca Callable associada. Aquesta és una versió sobrecarregada del mètode get (), on es pot especificar un temps determinat per esperar al resultat. És útil evitar un fil actual, que es pot bloquejar durant un període més llarg. Recordeu que el mètode get és un mètode síncron i que fins que la persona que es pugui trucar finalitzi la seva tasca i torni un valor, haurà d’esperar a que es pugui trucar.

També hi ha mètodes 'isDone ()' i 'isCancelled ()' per obtenir l'estat actual d'una tasca trucable associada. Penseu en l'exemple en què cal trobar una suma de tots els nombres d'un a 100. Podem fer un bucle d'1 a 100 seqüencialment i afegir-los finalment. Una altra possibilitat és dividir i conquerir. En aquest mètode, podem agrupar els nombres de manera que cada grup tingui exactament dos elements. Finalment, podem assignar aquest grup a un grup de fils. Per tant, cada fil retorna una suma parcial en paral·lel i després recopila aquestes sumes parcials i les afegeix per obtenir la suma completa.

Característiques de Callable i Future Class

• La classe anomenable és una interfície de tipus SAM i, per tant, es pot implementar a l'expressió lambda.

• La classe anomenable només té un mètode 'call ()' que conté tot el codi necessari per executar-se de manera asíncrona.

  convertir el doble a java enter

• En un entorn d’interfície executable, no hi havia cap possibilitat de retornar el resultat del càlcul o llançar una excepció comprovada. Mentre que amb Callable es retorna un valor i es genera una excepció marcada.

• El mètode Get () de la classe Future es pot utilitzar per recuperar resultats un cop feta la computació. Els usuaris també poden comprovar si el càlcul està acabat o no mitjançant el mètode done ().

• La cancel·lació del càlcul mitjançant el mètode future.cancel () també és una bondat en algunes aplicacions.

• Get () s’anomena trucada de bloqueig i continua bloquejant-se fins que s’acaba el càlcul.

Comparació de classes convocables i executables

A continuació es mostra un exemple senzill d’una classe anomenable Java implementada on el codi retorna el nom del fil específic, que està executant la tasca al cap d’un segon. Aquí utilitzem el framework extractor per executar 100 tasques en paral·lel amb Java Future fins al resultat de les tasques enviades. El primer fragment és la sortida i el següent representa el codi.

package 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 implements Callable {@Override public String call () throws Exception {Thread.sleep (1000) // return the name name executing this callable task return Thread.currentThread () .getName ()} public static void main (String args []) {// Obtingueu ExecutorService de la classe d'utilitat Executors, la mida de l'agrupació de fils és de 10 ExecutorService executor = Executors.newFixedThreadPool (10) // creeu una llista per mantenir el futur objecte associat a la llista de trucadesllista = nova ArrayList() // Crea una instància MyCallable 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() } } 

Tancament dels serveis d’executors

L’aspecte crucial i important que molts desenvolupadors troben a faltar és tancar ExecutorService. El servei ExecutorS és vital i es crea amb elements de fil addicionals. Recordeu que la JVM només s’atura quan s’aturen tots els fils que no són dimonis. Així, tanqueu el servei executor impedeix que la JVM s'aturi.

implementació simple de hashmap a Java

Per comunicar al servei executor que no cal executar els fils, hauríem de tancar el servei.

Hi ha tres maneres d’invocar l’aturada:

• aturada nul·la () - Això inicia un tancament ordenat en què s'executen les tasques enviades prèviament, però no s'accepten tasques noves.
• Llista de tancament Ara () - Intenta aturar totes les tasques que executen activament, atura el processament de tasques pendents i també retorna una llista de les tasques que estaven pendents d'execució.
• void awaitTermination () - Això continua bloquejant-se fins que totes les tasques han finalitzat l'execució després d'una sol·licitud de tancament, o es produeix el temps d'espera. També es bloqueja quan s’interromp el fil actual. Tot depèn de quina tasca sigui la primera.

Amb això, arribem al final de l'article de la interfície trucable a Java. Espero que tingueu una comprensió de la interfície futura i trucable a Java.

Consulteu el per Edureka, una empresa d'aprenentatge en línia de confiança amb una xarxa de més de 250.000 estudiants satisfets repartits per tot el món. El curs de formació i certificació Java J2EE i SOA d’Edureka està dissenyat per a estudiants i professionals que vulguin ser desenvolupador de Java.

Tens alguna pregunta? Si us plau, mencioneu-lo a la secció de comentaris d’aquest bloc “Interfície trucable a Java” i us respondrem el més aviat possible.