The Executor Framework has been introduced in Java 1.5 and it is a part of java.util.concurrent package. The Executor framework is an abstraction over the actual implementation of java multithreading. It is used for standardizing invocation, scheduling, execution and control of asynchronous tasks according to a set of execution policies defined during the creation of the constructor.
Before java 1.5, multithreading applications were created using thread group , thread pool or custom thread pool. Now the control of each thread has to be done by the programmer keeping in mind the following points
● Synchronization
● Locking
● Notification
● Dead lock
And many more that arises out of the application requirement. Some time it is very difficult to control multithreading applications because the behaviors of the threads are also dependent on the environment where the application is deployed and running. For example the processor speed, the RAM size, the band width all has a direct effect on the multithreading application. So you have to keep all these factors in mind before creating architecture.
An Executor framework provides multi-threading application programs with a easy abstraction for thinking about tasks. Instead of thinking in terms of threads, an application now deals simply with instances of Runnable (which is basically collections of tasks). And then it is passed to an Executor to process. Den ExecutorService grensesnitt utvider forenklede Executor grensesnitt og det er livsløps metoder for å håndtere den byrder rammeverket.
Byrder rammeverket representerer oppgaver ved hjelp av forekomster av kjørbart eller Callable. Kjørbart er kjørt () metoden ikke returnerer en verdi eller kaste en kontrollert unntak. Kallbart er en mer funksjonell versjon i det området. Den definerer en samtale () fremgangsmåte som tillater tilbakeføring av noen beregnede verdi som kan benyttes i fremtiden behandlingen. Og det kaster også et unntak hvis det er nødvendig.
Den FutureTask klassen brukes til å få fremtidig informasjon om behandlingen. En forekomst av denne klassen kan vikle enten en Callable eller et kjørbart. Du kan få en forekomst av dette som returverdien av sender () metode for en ExecutorService. You can also manually wrap your task in a FutureTask before calling execute () metode.
Following are the function steps to implement the ThreadPoolExecutor.
● A pool of multiple/single thread is created.
● A queue is created holding all the tasks but these tasks are not yet assigned to threads from the pool. Bounded and unbounded queues are available.
● Rejection handler is used to handle the situation when one or more tasks are not able to assign in the queue. As per the default rejection policy, it will simply throw a RejectedExecutionException runtime exception, and the application can catch it or discard it.
Following is an example to observe the life cycle of a executor framework. Here we will only discuss the basis steps and the basic interfaces. There are many more properties and subclasses available to handle different kind of applicant need.
The following class implements Runnable and its instances will be used as a task in the next section of code.
public class jobPrint implements Runnable {
private final String name;
private final int delay;
public jobPrint(String name, int delay) {
this.name = name;
this.delay = delay;
}
public void run() {
System.out.println("Starting: " + name);
try {
Thread.sleep(delay);
} catch (InterruptedException ignored) {
}
System.out.println("Done with: " + name);
}
}
The following class is implementing the executor tasks.
import java.util.concurrent.*;
import java.util.Random;
public class UseExecutorService {
public static void main(String args[]) {
Random random = new Random();
ExecutorService executor = Executors.newFixedThreadPool(3);
// Sum up wait times to know when to shutdown
int waitTime = 500;
for (int i=0; jeg<10; i ) {
String name = “NamePrinter ” + jeg;
int time = random.nextInt(1000);
waitTime = time;
Runnable runner = new jobPrint(navn, time);
System.out.println(“Adding: ” + navn + ” / ” + time);
executor.execute(runner);
}
prøve {
Thread.sleep(waitTime);
executor.shutdown();
executor.awaitTermination
(waitTime, TimeUnit.MILLISECONDS);
} fange (InterruptedException ignored) {
}
System.exit(0);
}
}
Create an executor
First create an instance of an Executor or ExecutorService. Den arvtakere klassen har en rekke statiske fabrikk metoder for å lage en ExecutorService. For example, newFixedThreadPool() returnerer en ThreadPoolExecutor forekomst med en initialisert og ubegrenset kø, og et fast antall tråder. Og newCachedThreadPool () returnerer en ThreadPoolExecutor eksempel initialisert med en grenseløs køen og ubegrenset antall tråder. I andre tilfelle, eksisterende tråder gjenbrukes hvis tilgjengelig.Hvis ingen gratis tråden er tilgjengelig, en ny opprettes og legges til bassenget. Tråder som har vært inaktiv i mer enn en timeout perioden vil bli fjernet automatisk fra bassenget.
Dette er en fast pool av 15 tråder.
private static endelige Executor byrder = Executors.newFixedThreadPool(15);
Dette er en bufret tråden bassenget
private static ExecutorService exec = Executors.newCachedThreadPool();
Følgende er en tilpasset tråden bassenget byrder. Parameterverdiene er avhengige av anvendelsen behovet. Her kjernen bassenget er å ha 5 tråder som kan kjøre samtidig og det maksimale antallet er 10. Køen er i stand til å holde 200 tasks. Her ett poeng bør bli husket at størrelsen bassenget bør holdes på et høyere side for å imøtekomme alle oppgaver. Hvile fristen holdes så 5 ms.
private static endelige Executor byrder = new ThreadPoolExecutor(5, 10, 50000L, TimeUnit.MILLISECONDS, ny LinkedBlockingQueue(200));
Lag en eller flere oppgaver og satt i kø
Lag en eller flere oppgaver som skal utføres som forekomster av enten kjørbart eller Callable.
Send inn oppgaven til Executor
Når du har opprettet ExecutorService, du må sende inn en oppgave til den ved hjelp av enten sende inn () eller utføre () metode. Nå en fri tråd fra bassenget vil automatisk ta oppgavene fra køen og kjøre den. Nå prosessen vil fortsette til alle oppgavene er ferdig fra køen.
Utføre oppgaven
Nå Executor er ansvarlig for å håndtere oppgaven henrettelse, tråden bassenget og kø. Hvis utvalget har mindre enn sin konfigurert rekke minimums tråder, nye tråder vil bli opprettet for å håndtere kø oppgaver til at grensen er nådd til den konfigurerte verdien. Hvis tallet er høyere enn den innstilte minimums, da utvalget ikke vil starte noen flere tråder. I stedet, oppgaven er kø før en tråd blir frigjort til å behandle forespørselen. Dersom køen er full, deretter en ny tråd er startet for å håndtere det.
Nedleggelse Executor
Termineringen utføres ved å kalle sin nedleggelse () metode. Du kan velge å avslutte det grasiøst, eller brått.
Dette er en stor post på multitasking i java
Takk
/Jhon