ThreadPoolExecutor

"Gewone programmeurs komen er vroeg of laat achter dat ze veel kleine taken hebben die van tijd tot tijd moeten worden uitgevoerd."

"Als je een game schrijft, zijn het de acties die individuele personages uitvoeren."

"Als je een webserver schrijft, komen er verschillende opdrachten van gebruikers binnen: upload een foto, transcodeer deze naar het gewenste formaat, pas de gewenste sjabloon toe, enz."

"Vroeg of laat worden alle grote taken opgedeeld in een reeks kleine, beheersbare taken."

"Dus gezien deze context rijst een subtiele vraag: hoe moet je ze allemaal beheren? Wat als je honderden taken in een minuut moet uitvoeren? Het zou weinig zin hebben om voor elke taak een thread te maken. De Java-machine wijst vrij veel bronnen toe voor elke thread."

"Met andere woorden, het maken en vernietigen van een thread kan meer tijd en middelen kosten dan de taak zelf."

"De makers van Java hebben een elegante oplossing voor dit probleem bedacht: ThreadPoolExecutor .

" ThreadPoolExecutor is een klasse met twee dingen erin:"

A)  Een taakwachtrij, waaraan u taken kunt toevoegen zodra deze zich in het programma voordoen.

B) Een threadpool, een groep threads die deze taken uitvoeren.

"Bovendien worden de threads niet vernietigd zodra een taak is voltooid. In plaats daarvan vallen ze in slaap om klaar te zijn om aan een nieuwe taak te beginnen zodra deze verschijnt."

"Wanneer u een ThreadPoolExecutor maakt, kunt u het maximum aantal aan te maken threads instellen en het maximum aantal taken dat in de wachtrij kan worden geplaatst. Met andere woorden, u kunt het aantal threads beperken tot bijvoorbeeld 10 en het aantal taken in de wachtrij tot 100."

"Dit is hoe ThreadPoolExecutor werkt:"

1)  Wanneer u een nieuwe taak toevoegt, wordt deze aan het einde van de wachtrij geplaatst.

2)  Als de wachtrij vol is, wordt er een uitzondering gegenereerd.

3)  Na het voltooien van een taak, neemt elke thread de volgende taak uit de wachtrij en begint deze uit te voeren.

4) Als er geen taken in de wachtrij staan, gaat een thread in de slaapstand totdat er nieuwe taken worden toegevoegd.

"De aanpak, waarbij we het aantal werkthreads beperken, is voordelig omdat hoe meer threads we hebben, hoe meer ze met elkaar interfereren. Het is veel effectiever om 5-10 werkthreads en een lange rij taken te hebben dan om 100 threads te creëren voor een golf van taken, die met elkaar zullen concurreren om middelen: geheugen, processortijd, toegang tot databases, enz."

"Hier is een voorbeeld van ThreadPoolExecutor in actie:"

ExecutorService service = Executors.newFixedThreadPool(2);

for(int i = 0; i < 10; i++)
{
 service.submit(new Runnable() {
    public void run()
    {
     // Here we download something big from the Internet.
    }
 });
}

"Eh, ik zie het niet..."

"Er wordt een ThreadPoolExecutor- object gemaakt wanneer de methode newFixedThreadPool wordt aangeroepen."

Het is dus heel gemakkelijk te gebruiken. Zodra je er een taak aan toevoegt met de verzendmethode:

A)  Wekt een slapende draad, als die er is, om de taak uit te voeren.

B)  Als er geen wachtende thread is, wordt er een nieuwe voor de taak gemaakt.

C)  Als het maximale aantal threads is bereikt, wordt de taak gewoon aan het einde van de wachtrij geplaatst.

"Ik heb met opzet "hier downloaden we iets groots van internet" in het voorbeeld opgenomen. Als we 100 taken hebben "download iets groots van internet", dan heeft het geen zin om er veel tegelijk uit te voeren - we' We zullen worden tegengehouden door de bandbreedtelimiet van onze internetverbinding. In dit geval zouden een paar threads voldoende moeten zijn. Dit is wat u ziet in het bovenstaande voorbeeld:"

ExecutorService service = Executors.newFixedThreadPool(2);

"Het blijkt dat werken met een heleboel taken niet zo moeilijk is."

'Ja. Nog makkelijker dan je je misschien kunt voorstellen. Maar daar zal Kim je wel over vertellen.'