Què és ExecutorService a Java i com crear-lo?

Aquest article tracta el concepte de subinterfície Executor ExecutorService a Java amb diversos exemples per explicar la creació i gestió de fils a Java.

El llenguatge de programació Java funciona de manera molt eficient aplicacions que requereixen que les tasques s'executin simultàniament en un fil. Es fa difícil per a qualsevol aplicació executar un gran nombre de fils simultàniament. Per superar aquest problema, ve amb ExecutorService que és una subinterfície de . En aquest article, parlarem de la funcionalitat d'ExecutorService a Java. A continuació es detallen els temes tractats en aquest bloc:



Què és Executor Framework?

És bastant més fàcil fer i executar un o dos fils simultàniament. Però es fa difícil quan el nombre de fils augmenta fins a un nombre significatiu. Les aplicacions multi-threads grans tindran centenars de fils en execució simultània. Per tant, té un sentit complet separar la creació de fils de la gestió de fils en una aplicació.



L'executor és un us ajuda a crear i gestionar fils en una aplicació. El us ajuda en les tasques següents.

  • Creació de fils: proporciona una varietat de mètodes per a la creació de fils que ajuden a executar les vostres aplicacions simultàniament.



  • Gestió de fils: també gestiona el cicle de vida del fil. No us preocupeu si el fil està actiu, ocupat o mort abans d’enviar la tasca a l’execució.

  • Enviament i execució de tasques: el marc Executor proporciona mètodes per a l'enviament de tasques a l'agrupació de fils. També dóna el poder de decidir si s'executarà o no el fil.

executorservice-executorservice a java -edureka

ExecutorService a Java Exemple

És una subinterfície del marc executor que afegeix certes funcionalitats per gestionar el cicle de vida del fil d'una aplicació. També proporciona un mètode submit () que pot acceptar tant executable com trucable objectes.



A l'exemple següent, crearem un ExecutorService amb un únic fil i després enviarem la tasca que s'executarà dins del fil.

import java.util.concurrent.ExecutorService import java.util.concurrent.Executors classe pública Exemple {public static void main (String [] args) {System.out.println ('Inside:' + Thread.currentThread (). getName ( )) System.out.println ('creando ExecutorService') ExecutorService executorservice = Executors.newSingleThreadExecutor () System.out.println ('creando un runnable') Runnable runnable = () -> {System.out.println ('inside: '+ Thread.currentThread (). GetName ())} System.out.println (' envia la tasca especificada per l'executable al servei executor ') executorservice.submit (executable)}}
 Sortida: Dins: principal creant ExecutorService creant un executable envia la tasca especificada per l'executable al servei executor dins: pool-1-thread-1

El de sobre mostra com podem crear un ExecutorService i executar una tasca dins de l'executor. Si s'envia una tasca a l'execució i el fil està ocupat executant una altra tasca, la tasca s'esperarà en una cua fins que el fil sigui lliure per executar-la.

Quan executeu el programa anterior, el programa no sortirà mai. Haureu de tancar-lo explícitament, ja que el servei executor continua escoltant noves tasques.

Implementacions de Java ExecutorService

ExecutorService és molt similar a un grup de fils. De fet, la implementació de l'ExecutorService a java.util.concurrent paquet és una implementació de grups de fils. ExecutorService té les implementacions següents al paquet java.util.concurrent:

ThreadPoolExecutor

El ThreadPoolExecutor executa les tasques donades mitjançant un dels seus fils agrupats internament.

Creació d’un threadPoolExecutor

int corePoolSize = 5 int maxPoolSize = 10 long keepAliveTime = 5000 ExecutorService threadPoolExecutor = nou threadPoolExecutor (corePoolSize, maxPoolSize, keepAliveTime, TimeUnit.MILLISECONDS, nova LinkedBlockingQueue ())

ScheduledThreadPoolExecutor

El programa java.util.concurrent.ScheduledThreadPoolExecutor és un ExecutorService que pot programar tasques per executar-se després d’un retard o executar-se repetidament amb un interval de temps fix entre cada execució.

Exemple

ScheduledExecutorService schedulexecutorservice = Executors.newScheduledThreadPool (5) ScheduledFuture schedulfuture = schedulExecutorService.schedule (new Callable () {public Object call () llança Exception {System.out.println ('executat') return 'anomenat'}}, 5, TimeUnit SEGONS)

Ús del servei Executor

Hi ha algunes maneres diferents de delegar tasques a un ExecutorService.

  • executar (executable)

  • enviar (Runnable)

  • invokeAny ()

  • invokeAll ()

Executa Runnable

Java ExecutorService execute (Runnable) pren un objecte java.lang.Runnable i l'executa de forma asíncrona.

ExecutorService executorService = Executors.newSingleThreadExecutor () executorService.execute (nou Runnable () {public void run () {System.out.println ('tasca asíncrona')}}) executorService.shutdown ()

No hi ha manera d’obtenir el resultat de l’execució de Runnable, per això heu d’utilitzar Callable.

Envia Runnable

El mètode Java ExecutorService submit (Runnable) pren una implementació Runnable i retorna un objecte futur. L'objecte futur es pot utilitzar per comprovar si Runnable s'ha acabat d'executar.

Future future = executorService.submit (new Runnable () {public void run () {System.out.println (: asynchronous task ')}}) future.get () // torna nul si la tasca s'ha acabat correctament.

Enviament trucable

El mètode Java ExecutorService submit (Callable) és similar a submit (Runnable), però requereix Java Callable en lloc de Runnable.

Future future = executorService.submit (new Callable () {public Object call () throws Exception {System.out.println ('Asynchronous callable') return 'Result Callable'}}) System.out.println ('future.get ( ) = 'future.get ())
 Sortida: Asynchroous callable future.get = Resultat trucable

invokeAny ()

El mètode invokeAny () pren una col·lecció d'objectes anomenables. La invocació d’aquest mètode no retorna cap futur, sinó que retorna el resultat d’un dels objectes anomenables.

ExecutorService executorService = Executors.newSingleThreadExecutor () Conjuntcallables = nou HashSet() callables.add (new Callable () {public String call () throws Exception {return'task A '}}) callables.add (new Callable () {public String call () throws Exception {return'task B'} }) callables.add (new Callable () {public String call () throws Exception {return'task C '}}) String result = executorService.invokeAny (callables) System.out.println (' result = '+ result) executorService .tancar()

Quan executeu el codi anterior, el resultat canvia. Pot ser la tasca A, la tasca B, etc.

InvokeAll ()

El mètode invokeAll () invoca tots els objectes trucables passats com a paràmetres. Retorna els objectes futurs que es poden utilitzar per obtenir els resultats de l'execució de cada Callable.

ExecutorService executorService = Executors.newSingleThreadExecutor () Conjuntcallables = nou HashSet() callables.add (new Callable () {public String call () throws Exception {return 'Task A'}}) callables.add (new Callable () {public String call () throws Exception {return 'Task B'} }) callables.add (nova Callable () {public String call () llença Exception {return 'Task C'}}) Llistafutures = executorService.invokeAll (callables) per a (Futur futur: futurs) {System.out.println ('future.get =' + future.get ())} executorService.shutdown ()

Runnable vs Callable

Les interfícies executables i trucables són molt similars entre si. La diferència és visible a la declaració del fitxer interfícies. Les dues interfícies representen una tasca que pot executar-se simultàniament mitjançant un fil o un ExecutorService.

Declaració exigible:

interfície pública cridable {public object call () throws Exception}

Declaració executable:

interfície pública Runnable {public void run ()}

La principal diferència entre tots dos és que el mètode call () pot retornar un objecte de la trucada al mètode. I el mètode call () pot llançar un fitxer mentre el mètode run () no pot.

programa Java per a sèries Fibonacci

cancel·la la tasca

Podeu cancel·lar la tasca enviada a ExecutorService simplement trucant al mètode de cancel·lació en el futur enviat quan s’enviï la tasca.

future.cancel ()

ExecutorService Shutdown

Per evitar que els fils s'executin fins i tot després de completar l'execució, hauríeu de tancar l'ExecutorService.

tancar()

Per acabar els fils dins d’un ExecutorService podeu trucar al mètode shutdown ().

executorService.shutdown ()

Això ens porta al final d’aquest article, on hem après com podem utilitzar ExecutorService per executar tasques en un fil. Espero que tingueu clar tot el que us ha estat compartit en aquest tutorial.

Si heu trobat rellevant aquest article sobre 'ExecutorService in Java', consulteu el document 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.

Estem aquí per ajudar-vos en cada pas del vostre viatge i oferir un pla d’estudis dissenyat per a estudiants i professionals que vulguin ser desenvolupador de Java. El curs està dissenyat per donar-vos un avantatge en la programació de Java i formar-vos tant per conceptes bàsics com avançats de Java juntament amb diversos M'agrada Hibernar & .

Si teniu alguna pregunta, no dubteu a fer-vos totes les vostres preguntes a la secció de comentaris de 'ExecutorService a Java' i el nostre equip estarà encantat de respondre-us.