Come implementare l'interfaccia richiamabile in Java

Questo articolo ti fornirà una conoscenza dettagliata e completa di come implementare Callable Interface in Java con esempi.

I programmi multithreading Java testimoniano l'uso di estesi file Richiamabile e futuro. Con la conoscenza dei prerequisiti dei thread e del multi-threading, i lettori saranno in grado di cogliere meglio la discussione in questo articolo. Come spiegherò Callable Interface in Java in questo articolo.

Riepilogo dei thread

Tuttavia, lasciatemi solo dare una breve introduzione al concetto di thread. Un thread è un percorso di esecuzione separato, nel caso in cui sia necessario eseguire un'attività ripetitiva, il lavoro può essere suddiviso in più attività e assegnarle ai thread. Multi-threadingnon è altro che assegnare più thread per eseguire diverse attività in parallelo per ottenere rapidamente il risultato.





Che cos'è l'interfaccia richiamabile in Java

Per Java 5, è stata introdotta la classe 'java.util.concurrent'. Questa interfaccia richiamabile è stata introdotta tramite il pacchetto di concorrenza che sembrava simile all'interfaccia Runnable. Può anche restituire qualsiasi oggetto ed è in grado di lanciare un'eccezione. Un'interfaccia Java Callable utilizza Generics, rendendo così possibile restituire qualsiasi tipo di oggetto. Executor Framework fornisce un metodo submit () per eseguire implementazioni Callable in un pool di thread. In realtà, Java Executor Framework aderisce ai modelli WorkerThread.

java-interfaceIn un pool di thread gli utenti possono avviare i thread utilizzando il metodo Executors.newFixedThreadPool (10) e di conseguenza sottoporgli un'attività. Un eseguibile funge da obiettivo di un thread e un metodo pubblico void run () è obbligatoriamente implementato per definire l'attività. Questo verrà eseguito dai thread nel pool di thread. In base alla disponibilità dei thread nel pool, Executor Framework assegna il lavoro (destinazione eseguibile) ai thread.Se tutti i thread sono in uso, l'attività deve essere bloccata. Dopo che il thread ha completato un'attività, torna nel pool come thread disponibile, pronto ad accettare attività future. Callable è simile a Runnable e può restituire qualsiasi tipo di oggetto quando vogliamo ottenere un risultato o uno stato dall'attività.



Ritorno dell'interfaccia richiamabile

Java Callable restituisce java.util.concurrent. Java Future offre un metodo cancel () per eliminare l'attività Callable associata. Questa è una versione sovraccaricata del metodo get (), in cui è possibile specificare un certo tempo di attesa per il risultato. È utile per evitare un thread corrente, che potrebbe essere bloccato per un periodo più lungo. Ricorda che il metodo get è un metodo sincrono e finché il chiamabile non termina la sua attività e restituisce un valore, dovrà attendere per un chiamabile.

Ci sono anche metodi 'isDone ()' e 'isCancelled ()' per recuperare lo stato corrente di un'attività Callable associata. Considera l'esempio in cui è necessario trovare una somma di tutti i numeri da uno a 100. Possiamo ripetere da 1 a 100 in sequenza e aggiungerli alla fine. Un'altra possibilità è dividendo e conquistando. In questo metodo, possiamo raggruppare i numeri in modo tale che ogni gruppo abbia esattamente due elementi. Infine, possiamo assegnare quel gruppo a un pool di thread. Pertanto, ogni thread restituisce una somma parziale in parallelo e quindi raccoglie quelle somme parziali e le aggiunge per ottenere l'intera somma.



java ha una relazione

Caratteristiche di Callable e Future Class

  • La classe Callable è un'interfaccia di tipo SAM e quindi può essere implementata nell'espressione lambda.

    ansible vs chef vs puppet
  • La classe richiamabile ha un solo metodo 'call ()' che contiene tutto il codice necessario per eseguire in modo asincrono.

  • In un ambiente di interfaccia eseguibile, non era possibile restituire il risultato del calcolo o lanciare un'eccezione controllata. Mentre con Callable è disponibile la restituzione di un valore e il lancio di un'eccezione selezionata.

  • Il metodo Get () della classe Future può essere utilizzato per recuperare i risultati una volta terminato il calcolo. Gli utenti possono anche verificare se il calcolo è terminato o meno utilizzando il metodo done ().

  • Annullare il calcolo utilizzando il metodo future.cancel () è anche un vantaggio in alcune applicazioni.

  • Get () è chiamata chiamata di blocco e continua a bloccarsi fino al completamento del calcolo.

Confronto di classi richiamabili ed eseguibili

Richiamabile Runnable
Fa parte del ' java.util.concurrent ' pacchetto da Java 1.5Fa parte del pacchetto java.lang a partire da Java 1.0
Un'interfaccia parametrizzata, come CallableUn'interfaccia non parametrizzata
Capace di lanciare un'eccezione controllataNon può generare un'eccezione controllata
Contiene un unico metodo, call (), che restituisce il tipo V, è lo stesso del parametro di interfaccia definito 'Tipo'Qui, contiene un singolo metodo, chiamato run (), che restituisce void

Di seguito è riportato un semplice esempio di una classe richiamabile Java implementata in cui il codice restituisce il nome del thread specifico, che esegue l'attività dopo un secondo. Qui utilizziamo il framework dell'estrattore per eseguire 100 attività in parallelo con Java Future al risultato delle attività inviate. Il primo frammento è l'output e quello di seguito rappresenta il codice.

pacchetto 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 implementa Callable {@Override public String call () genera un'eccezione {Thread.sleep (1000) // restituisce il nome del thread eseguendo questa attività richiamabile return 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) // create a list to hold the Future oggetto associato a Callable Listlist = new ArrayList() // Crea istanza 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() } } 

Chiusura dei servizi Executor

L'aspetto cruciale e importante che molti sviluppatori mancano è chiudere ExecutorService. ExecutorService è fondamentale e viene creato con elementi thread aggiuntivi. Tenere presente che la JVM si arresta solo quando tutti i thread non daemon vengono arrestati. Pertanto, la semplice chiusura del servizio esecutore impedisce l'arresto della JVM.

Per indicare al servizio di esecuzione che non è necessario eseguire i thread, è necessario chiudere il servizio.

Esistono tre modi per richiamare l'arresto:

  • void shutdown () - Avvia un arresto ordinato in cui vengono eseguite le attività inviate in precedenza, ma non vengono accettate nuove attività.
  • Elenco shutdownNow () - Tenta di interrompere tutte le attività in esecuzione attiva, interrompe l'elaborazione delle attività in sospeso e restituisce anche un elenco delle attività che erano in attesa di esecuzione.
  • void awaitTermination () - Questo continua a bloccarsi finché tutte le attività non hanno terminato l'esecuzione dopo una richiesta di arresto o si verifica il timeout. Si blocca anche quando il thread corrente viene interrotto. Tutto dipende da quale attività viene prima.

Con questo, arriviamo alla fine dell'articolo Callable Interface in Java. Spero che tu abbia compreso Future and Callable Interface in Java.

come diventare un ingegnere di intelligenza artificiale

Controlla il da Edureka, una società di formazione online affidabile con una rete di oltre 250.000 studenti soddisfatti sparsi in tutto il mondo. Il corso di formazione e certificazione Java J2EE e SOA di Edureka è progettato per studenti e professionisti che desiderano diventare sviluppatori Java.

Hai domande per noi? Si prega di menzionarlo nella sezione commenti di questo blog 'Interfaccia richiamabile in Java' e ti risponderemo il prima possibile.