Wat zijn de voordelen van het gebruik van een ExecutorService?

Wat is het voordeel van het gebruik van ExecutorServiceten opzichte van het uitvoeren van threads die een Runnabledoorgeven aan de Thread-constructor?


Antwoord 1, autoriteit 100%

ExecutorServiceabstraheert veel van de complexiteiten die gepaard gaan met abstracties op een lager niveau, zoals onbewerkte Thread. Het biedt mechanismen voor het veilig starten, afsluiten, indienen, uitvoeren en blokkeren van de succesvolle of abrupte beëindiging van taken (uitgedrukt als Runnableof Callable).

Van JCiP, Sectie 6.2, rechtstreeks uit de mond van het paard:

Executormag dan een eenvoudige interface zijn, het vormt de basis voor een flexibel en krachtig raamwerk voor asynchrone taakuitvoering dat een breed scala aan beleidsregels voor taakuitvoering ondersteunt. Het biedt een standaard manier om taakverzendinglos te koppelen van taakuitvoering, en beschrijft taken als Runnable. De implementaties van Executorbieden ook levenscyclusondersteuning en hooks voor het toevoegen van statistieken, applicatiebeheer en monitoring.

Het gebruik van een Executoris meestal de gemakkelijkste manier om een ​​producent-consument-ontwerp in uw toepassing te implementeren.

In plaats van uw tijd te besteden aan het implementeren (vaak onjuist en met veel moeite) van de onderliggende infrastructuur voor parallellisme, stelt het j.u.concurrent-framework u in plaats daarvan in staat om u te concentreren op het structureren van taken, afhankelijkheden en mogelijk parallellisme. Voor een groot aantal gelijktijdige toepassingen is het eenvoudig om taakgrenzen te identificeren en te benutten en gebruik te maken van j.u.c, zodat u zich kunt concentreren op de veel kleinere subset van echte gelijktijdigheidsuitdagingen waarvoor mogelijk meer gespecialiseerde oplossingen nodig zijn.

Ook, ondanks de standaard look en feel, is de Oracle API-pagina met een samenvatting van de gelijktijdigheidshulpprogramma’sbevat enkele echt solide argumenten om ze te gebruiken, niet in de laatste plaats:

Ontwikkelaars waarschijnlijk al
de standaardbibliotheek begrijpen
lessen, dus het is niet nodig om te leren
de API en het gedrag van ad-hoc
gelijktijdige componenten. Aanvullend,
gelijktijdige toepassingen zijn ver weg
eenvoudiger te debuggen wanneer ze zijn gebouwd
op betrouwbare, goed geteste componenten.

Deze vraag over SOgaat over een goed boek, waarop het onmiddellijke antwoord is JCiP. Als je dat nog niet hebt gedaan, zorg dan dat je een exemplaar krijgt. De alomvattende benadering van gelijktijdigheid die daar wordt gepresenteerd, gaat veel verder dan deze vraag en zal u op de lange termijn veel hartzeer besparen.


Antwoord 2, autoriteit 38%

Een voordeel dat ik zie, is het beheren/plannen van meerdere threads. Met ExecutorService hoeft u niet uw eigen threadmanager te schrijven die geplaagd kan worden door bugs. Dit is vooral handig als uw programma meerdere threads tegelijk moet uitvoeren. Als u bijvoorbeeld twee threads tegelijk wilt uitvoeren, kunt u dit eenvoudig als volgt doen:

ExecutorService exec = Executors.newFixedThreadPool(2);
exec.execute(new Runnable() {
  public void run() {
    System.out.println("Hello world");
  }
});
exec.shutdown();

Het voorbeeld is misschien triviaal, maar probeer te denken dat de regel “hallo wereld” uit een zware bewerking bestaat en u wilt dat die bewerking in meerdere threads tegelijk wordt uitgevoerd om de prestaties van uw programma te verbeteren. Dit is slechts één voorbeeld, er zijn nog steeds veel gevallen waarin u meerdere threads wilt plannen of uitvoeren en ExecutorService als uw threadmanager wilt gebruiken.

Voor het uitvoeren van een enkele thread zie ik geen duidelijk voordeel van het gebruik van ExecutorService.


Antwoord 3, autoriteit 27%

De volgende beperkingen van traditionele Thread worden overwonnen door het Executor-framework (ingebouwd Thread Pool-framework).

  • Slecht resourcebeheerd.w.z. het blijft voor elk verzoek nieuwe bronnen creëren. Geen limiet voor het maken van bronnen. Met behulp van het Executor-framework kunnen we de bestaande bronnen hergebruiken en beperkingen stellen aan het maken van bronnen.
  • Niet robuust: als we doorgaan met het maken van een nieuwe thread, krijgen we een StackOverflowException-uitzondering, waardoor onze JVM crasht.
  • Overhead Creëren van tijd: Voor elk verzoek moeten we een nieuwe bron creëren. Het creëren van een nieuwe bron is tijdrovend. d.w.z. Thread creëren > taak. Met behulp van het Executor-framework kunnen we in Thread Pool worden gebouwd.

Voordelen van threadpool

  • Het gebruik van Thread Pool verkort de reactietijd door het maken van threads tijdens het verwerken van verzoeken of taken te vermijden.

  • Gebruik van Thread Pool stelt u in staat uw uitvoeringsbeleid naar behoefte te wijzigen. je kunt van een enkele thread naar meerdere threads gaan door de ExecutorService-implementatie te vervangen.

  • Thread Pool in Java-toepassing verhoogt de stabiliteit van het systeem door een geconfigureerd aantal threads te maken dat wordt bepaald op basis van de systeembelasting en beschikbare bronnen.

  • Thread Pool verlost applicatieontwikkelaars van threadbeheer en stelt u in staat zich te concentreren op bedrijfslogica.

Bron


Antwoord 4, autoriteit 15%

Hieronder staan ​​enkele voordelen:

  1. Uitvoerder-service beheert thread op asynchrone manier
  2. Gebruik Future callable om het retourresultaat te krijgen nadat de thread is voltooid.
  3. Beheer de toewijzing van werk aan gratis threads en verkoop voltooid werk van thread om automatisch nieuw werk toe te wijzen
  4. fork – sluit u aan bij framework voor parallelle verwerking
  5. Betere communicatie tussen threads
  6. invokeAll en invokeAny geven meer controle om een ​​of alle threads tegelijk uit te voeren
  7. afsluiten biedt de mogelijkheid om al het aan de thread toegewezen werk te voltooien
  8. Geplande Executor Services bieden methoden voor het produceren van herhaalde aanroepen van runnables en callables
    Ik hoop dat het je zal helpen

Antwoord 5, autoriteit 6%

ExecutorService geeft ook toegang tot FutureTask die de resultaten van een achtergrondtaak terugstuurt naar de aanroepende klasse zodra deze is voltooid. In het geval van implementatie van Callable

public class TaskOne implements Callable<String> {
@Override
public String call() throws Exception {
    String message = "Task One here. . .";
    return message;
    }
}
public class TaskTwo implements Callable<String> {
@Override
public String call() throws Exception {
    String message = "Task Two here . . . ";
    return message;
    }
}
// from the calling class
ExecutorService service = Executors.newFixedThreadPool(2);
    // set of Callable types
    Set<Callable<String>>callables = new HashSet<Callable<String>>();
    // add tasks to Set
    callables.add(new TaskOne());
    callables.add(new TaskTwo());
    // list of Future<String> types stores the result of invokeAll()
    List<Future<String>>futures = service.invokeAll(callables);
    // iterate through the list and print results from get();
    for(Future<String>future : futures) {
        System.out.println(future.get());
    }

Antwoord 6

Als u een groot aantal threads maakt zonder beperking tot de maximale drempel, kan het heapgeheugen van de toepassing vol raken. Daarom is het maken van een ThreadPool een veel betere oplossing. Met ThreadPool kunnen we het aantal threads beperken dat kan worden gepoold en hergebruikt.

Uitvoerdersraamwerk vergemakkelijken het proces van het maken van threadpools in java. De klasse Executors biedt een eenvoudige implementatie van ExecutorService met behulp van ThreadPoolExecutor.

Bron:

Wat is Executors Framework

Other episodes