Introductie van Thread Life Cycle op Java
Een rode draad kent talloze fasen in de levenscyclus. Zoals, een draad komt in de wereld, begon, loopt en gaat daarna weg. Het volgende diagram verklaart de volledige levenscyclus van de draad.
- Thread Constructor produceert een thread door een nieuwe status.
- Bellen met de methode in Thread kan de uitvoerbare status bereiken.
- Thread Scheduler betreffende Java voert die thread uit wanneer de processor ontvangt.
- Wanneer de thread naar een geblokkeerde status zou gaan, wordt deze opnieuw uitgevoerd omdat deze teruggaat naar een uitvoerbare status.
- Als naar de wachtmethode wordt verwezen als thread, zou dit gaan naar wachten op de status, het zou naar de uitvoerbare status gaan zodra het een melding wordt tijdens de Inform en een kennisgevingsmethode.
- Draad eindigt zodra de run-methode wordt beëindigd.
Wat is draad?
Een thread wordt gedefinieerd op het niveau van het besturingssysteem. En de Java-taal, evenals alle andere talen, maakt gebruik van, de service die wordt geboden door het besturingssysteem. Vanuit het oogpunt van de ontwikkelaar is een thread een set instructies die we onze applicatie gaan schrijven en op een bepaalde manier uitvoeren. Een applicatie zelf kan uit meerdere threads bestaan. Verschillende threads kunnen tegelijkertijd worden uitgevoerd. De JVM (Java Virtual Machine) werkt met verschillende threads. Er zijn threads voor de afvalinzameling. Er zijn threads voor de Just in Time Compiler en andere technische threads.
States of Thread Life Cycle op Java
Hieronder staan de verschillende staten van de Thread Life Cycle op Java:
1. Nieuw: een nieuwe draad begint hun levenscyclus in de nieuwe staat. Het blijft in deze toestand voordat het programma met de thread begint. Bovendien staat het bekend als een gemaakte thread.
2. Runnable: Nadat een recent geboren thread kan beginnen, wordt de thread runnable. Een thread met deze status wordt beschouwd als het uitvoeren van hun proces.
3. Wachten: af en toe, een thread overgang naar het wachten rond de staat, hoewel de thread wacht op een andere thread om een activiteit uit te voeren. Een thread gaat alleen terug naar de uitvoerbare status als een extra thread aangeeft welke wachtende thread moet worden uitgevoerd.
4. Getimed wachten: een uitvoerbare thread kan gemakkelijk het specifieke getimede wachten op de status ophalen om een specifiek tijdsinterval te krijgen. Een thread met deze status gaat terug naar de uitvoerbare status zodra dat puntinterval afloopt of als de gebeurtenis waarop het echt wacht, gebeurt.
5. Beëindigd: een uitvoerbare thread komt in de beëindigde staat omdat deze zijn taak volbrengt of anders wordt beëindigd.
Hoe maak je een draad in Java?
De meest eenvoudige manier om een thread in Java te maken, is door het Runnable Pattern te gebruiken. U moet eerst een exemplaar van de Runnable-interface maken, wat erg eenvoudig is; er is slechts één methode om te implementeren. Vervolgens geven we deze instantie door aan de constructor van de klasse Thread. En dan roepen we gewoon de start () -methode van dit gecreëerde threadobject aan om een nieuwe thread te starten die de taak uitvoert die in ons Runnable-object is verpakt.
Dus eerst maken we een instantie van een Runnable. Er is slechts één te implementeren methode, die de methode run () wordt genoemd. Dit is het Java 7-patroon om dat te doen, met een instantie van een anonieme klasse. Maar we kunnen ook een lambda-expressie gebruiken om een Runnable te implementeren, omdat er slechts één methode is in de Runnable-interface.
Laten we discussies maken over zeer eenvoudige voorbeelden
We gaan kijken wat er mis kan gaan met een raceconditie die bestaat uit niet-gesynchroniseerde code die moet worden gesynchroniseerd en we gaan onze code repareren met behulp van synchronisatie. Dit eerste voorbeeld is heel eenvoudig, het is erg basic. Het gaat gewoon om het creëren van een taak.
Output:
Een taak is een exemplaar van de Runnable-interface, laten we het runnable noemen, en we kunnen deze interface implementeren met behulp van een lambda-expressie. Deze taak wordt gegeven aan een nieuwe thread en uitgevoerd in de context van deze thread. We gaan dus gewoon de naam afdrukken van de thread die deze taak uitvoert. Ik gebruik in … Thread.currentThread () is een statische methode van de klasse Thread die de thread retourneert die de huidige taak uitvoert. En we moeten gewoon getName () aanroepen op dit threadobject om de naam van een thread te retourneren. Daarna maken we een thread-instantie t = nieuwe thread. Dit doorgeven als parameter. Dus deze thread gaat dit stukje code uitvoeren. En om het te lanceren. t.start () dit is de methode start () die we moeten aanroepen. Wat we ook kunnen doen, is een expliciete naam voor deze thread geven met t.setName ('Mijn thread'). En nu kunnen we deze code uitvoeren. Nu roepen we in plaats van de methode start () de methode run () aan, en als we deze code uitvoeren, is het probleem dat de taak correct wordt uitgevoerd, maar niet wordt uitgevoerd in de thread die we hebben gemaakt. Het wordt uitgevoerd in de hoofdthread, dat is de thread die de hoofdmethode uitvoert. Dus deze run () -methode moet niet worden aangeroepen als we een nieuwe thread willen starten.
Output:
Methoden van Thread Life Cycle in Java
De methoden beschreven door eenvoudig Thread worden gepresenteerd in tabel.
| Gegevenstypen | Draad Methode Namen |
| Draad |
getName () Retourneer de naam van deze thread |
| int | prioriteit krijgen ()
Retourneert de prioriteit van de thread |
| boolean | is levend()
Test of deze draad nog loopt |
| leegte | join ()
Wacht tot deze draad sterft (beëindigen) |
| leegte | rennen()
Telkens wanneer deze thread werd gebouwd met behulp van een afzonderlijk Runnable-object, wordt de run-methode van het Runnable-object meestal genoemd; of anders keert deze methode niet zo goed terug. Wanneer de threadklasse ook kan worden uitgebreid, wordt de methode run () overschreven tijdens de subklasse en wordt de methode run-) overschreven. |
| leegte | setName ( tekenreeksnaam )
Wijzigt de naam met deze thread om vergelijkbaar te worden met de naam van het argument. |
| statische leegte | slaap ( lange millis ) gooit onderbroken / uitzondering Zorgt ervoor dat de draad die momenteel wordt uitgevoerd, rust de vereiste hoeveelheid milliseconden. |
| statische leegte | slaap ( lange millis, int nanos ) gooit InterruptedException
Het zorgt ervoor dat de draad die momenteel wordt uitgevoerd, slaapt (de uitvoering staakt) voor de vereiste hoeveelheid milliseconden en de specifieke hoeveelheid nanoseconden. |
| leegte | begin()
Triggers deze threads om de uitvoering te starten; de Java Virtual Machine roept de run-methode van die thread aan. |
| statische leegte | opbrengst()
Hiermee wordt het huidige threadobject geactiveerd om kort te pauzeren en extra threads toe te staan om uit te voeren. |
| statische draad | currentThread ()
Retourneert een vermelding van het momenteel uitvoerende threadobject. |
Conclusie
- Eenvoudig om draden te gebruiken, uiterst moeilijk te begrijpen.
- Het is een uitdaging om klassen te ontwerpen die methoden bevatten die draadveilig kunnen zijn.
- Lees: JavaDoc om de klasse java.lang.Thread te krijgen
Aanbevolen artikel
Dit is een gids voor de levenscyclus van de draad in Java. Hier bespreken we wat draad is? en verschillende toestanden van de levenscyclus van draden samen met het creëren van draden in Java. U kunt ook onze andere voorgestelde artikelen doornemen voor meer informatie -
- Frameworks in Java
- Sterpatronen in Java
- Sorteer samenvoegen in Java
- Beste Java-compilers
- Statische methode in PHP