"Hallo, Amigo! We hebben een nieuw en erg moeilijk onderwerp. Het spijt me. Het wordt vaak beschouwd als een van de meest complexe onderwerpen, niet alleen in Java, maar ook in het programmeren in het algemeen. Ik heb het over multithreading . "
Stel je een typisch computerspel voor, bijvoorbeeld een ruimteschip-racegame. Je vliegt door de uitgestrektheid van de kosmos en ontwijkt meteorieten en patrouillewagens. Twee dozijn anderen nemen met jou deel aan deze illegale races.
Laten we zeggen dat je besluit om zo'n spel te schrijven. Je programma zal commando's moeten bijhouden (toetsenbordinvoer), de ruimteschepen moeten verplaatsen, hun trajecten moeten berekenen, de gevolgen van eventuele botsingen moeten bepalen en dit alles op het scherm van de gebruiker moeten tekenen. Dit is zeer complex werk.
Weet je nog hoe we het "probleem van grote complexiteit" hebben opgelost in het voorbeeld over de groeiende rederij?
We hebben het opgedeeld in onafhankelijke afdelingen en strikt gespecificeerd (gestandaardiseerd) hoe ze zouden kunnen interageren.
"Maar wat doen we als de onafhankelijke delen parallel met de andere delen wat werk moeten verrichten?! Het antwoord op deze vraag is threads ."
Probeer je een programma voor te stellen als een kleine robot die rond de code loopt en commando's uitvoert . Eerst voert het een opdracht uit op de ene regel, gaat dan naar de volgende, enzovoort.
"Ik zie het voor me. Een fluitje van een cent!"
"Heel goed. En stel je nu voor dat je meerdere van deze robots hebt. Terwijl de ene de gebruikersinvoer verwerkt, werkt een tweede objecten bij op basis van die invoer. Een derde voert de code uit om deze objecten op het scherm weer te geven. Meerdere keren per seconde, een vierde controleert of er schepen in aanvaring zijn gekomen en berekent, als dat het geval is, de gevolgen van de aanvaring."
Zo kunnen we het programma niet alleen opdelen in zelfstandige onderdelen/objecten, maar er ook voor zorgen dat deze onderdelen onafhankelijk van elkaar hun werk kunnen doen. Hoe minder interactie tussen de afzonderlijke onderdelen, hoe minder complex het programma.
Stel je voor dat je de manager zou kunnen vervangen door een script dat brieven verstuurt . En de andere bedrijfsafdelingen konden niet eens zien dat er een verandering was geweest. Dit soort dingen gebeurde al in de 26e eeuw met uitstekende resultaten. De meeste managers, en zelfs topmanagers, kunnen met succes worden vervangen door een script van gemiddelde complexiteit. Pas nadat de "kantoorplanktonvakbond" tussenbeide kwam, kwam er een einde aan de massale ontslagen van managers. Maar ik dwaal af.
"Hoe interessant!"
"Er kunnen niet alleen meerdere van deze "kleine robots" code uitvoeren, ze kunnen ook met elkaar communiceren en nieuwe robots voortbrengen."
"Nieuwe robots spawnen?"
"Ja, om nieuwe taken uit te voeren. Soms is het voordelig om een andere robot (een andere thread) te maken om tegelijkertijd met de huidige thread (robot) een actie uit te voeren."
" Dit klinkt als een goede zaak, maar ik kan niet bedenken waar ik het zou gebruiken. "
En waarom noemen we ze " threads "?
"Stel je voor dat elke robot een andere kleur heeft en commando's markeert met zijn kleur terwijl hij ze uitvoert. Het pad dat de kleine robot volgt, is als de lijn die een potlood achterlaat. Dit pad loopt achter de robot langs, als een draad achter een naald."
Elke «kleine robot» heeft een taak waarvoor hij gemaakt is. U kunt denken aan een thread is de reeks opdrachten die worden uitgevoerd tijdens het uitvoeren van deze taak.
Laten we zeggen dat je op een ruimteschip vliegt om vracht af te leveren. Dan is «vracht afleveren» jouw taak, en je bent bezig met de uitvoering ervan. En je vliegroute is je rode draad. We zouden kunnen zeggen dat elke nieuwe taak, elke taak die nog niet voltooid is, zijn eigen rode draad heeft (een pad dat nog bewandeld moet worden).
"Met andere woorden, er is een taak en een "kleine robot" die deze uitvoert. En een draad is gewoon het pad dat de robot volgt terwijl hij zijn taak voltooit?"
"Precies."
Zo werkt het allemaal diep van binnen. Omdat de computer maar één processor heeft, kan hij maar één opdracht tegelijk uitvoeren. Dus hier is wat er gebeurt: de processor schakelt constant tussen threads. Het schakelt over naar een nieuwe thread, voert een paar commando's uit, schakelt dan over naar de volgende thread, voert een paar commando's uit, enzovoort. Maar aangezien het schakelen tussen threads honderden keren per seconde gebeurt, lijkt het ons dat alle threads tegelijkertijd draaien.
