Voordat u de draadconcept konden we niet meer dan één taak parallel uitvoeren. Het was een nadeel, en om dat nadeel weg te nemen, Draadconcept werd geïntroduceerd.
A Draad is een heel lichtgewicht proces, of we kunnen zeggen het kleinste deel van het proces dat ervoor zorgt dat een programma efficiënter kan werken door meerdere taken tegelijkertijd uit te voeren.
15 van 100,00
Om ingewikkelde taken op de achtergrond uit te voeren, gebruikten we de Draadconcept in Java . Alle taken worden uitgevoerd zonder dat dit het hoofdprogramma beïnvloedt. In een programma of proces hebben alle threads hun eigen afzonderlijke pad voor uitvoering, dus elke thread van een proces is onafhankelijk.
Nog een voordeel van het gebruik draad is dat als een thread een uitzondering of een fout krijgt op het moment van uitvoering, dit geen invloed heeft op de uitvoering van de andere threads. Alle threads delen een gemeenschappelijk geheugen en hebben hun eigen stapel, lokale variabelen en programmateller. Wanneer meerdere threads tegelijkertijd parallel worden uitgevoerd, staat dit proces bekend als Multithreading .
Simpel gezegd is een Thread een:
- Functie waarmee we meerdere activiteiten binnen één proces kunnen uitvoeren.
- Lichtgewicht proces.
- Reeks uitgevoerde uitspraken.
- Geneste reeks methodeaanroepen.
Draadmodel
Net als een proces bestaat een thread in verschillende toestanden. Deze toestanden zijn als volgt:
1) Nieuw (klaar voor gebruik)
Er is een draadje binnen Nieuw als het CPU-tijd krijgt.
2) Hardlopen
Er is een draadje binnen een rennen Geef aan wanneer het wordt uitgevoerd.
tekenreeks bevat
3) Opgeschort
Er zit een draadje in Opgeschort status wanneer deze tijdelijk inactief is of wordt uitgevoerd.
4) Geblokkeerd
Er zit een draadje in Geblokkeerd geeft aan wanneer het op hulpbronnen wacht.
5) Beëindigd
Een thread komt in deze toestand wanneer de uitvoering ervan op een gegeven moment onmiddellijk wordt stopgezet.
Draad creëren
Een thread wordt gemaakt door het 'creëren of implementeren' van de Uitvoerbare interface of door het verlengen van de Draadklasse . Dit zijn de enige twee manieren waarop we een draad kunnen creëren.
Laten we eens kijken naar de details van beide manieren om een thread te maken:
Draadklasse
A Draadklasse heeft verschillende methoden en constructors waarmee we verschillende bewerkingen op een thread kunnen uitvoeren. De klasse Thread breidt de Voorwerp klas. De Voorwerp klasse implementeert de Uitvoerbaar koppel. De threadklasse heeft de volgende constructors die worden gebruikt om verschillende bewerkingen uit te voeren.
Uitvoerbare interface(run() methode)
De Runnable-interface moet worden geïmplementeerd door die klasse waarvan de instanties bedoeld zijn om door een thread te worden uitgevoerd. De uitvoerbare interface geeft ons de loop() methode om een actie voor de thread uit te voeren.
start() methode
De methode wordt gebruikt voor het starten van een thread die we nieuw hebben gemaakt. Er wordt een nieuwe thread gestart met een nieuwe callstack. Na het uitvoeren van de begin() methode, verandert de thread de status van Nieuw in Uitvoerbaar. Het voert de run() methode wanneer de thread de juiste tijd krijgt om deze uit te voeren.
Laten we een voorbeeld nemen om te begrijpen hoe we een Java thread door de Thread-klasse uit te breiden:
ThreadVoorbeeld1.java
// Implementing runnable interface by extending Thread class public class ThreadExample1 extends Thread { // run() method to perform action for thread. public void run() { int a= 10; int b=12; int result = a+b; System.out.println('Thread started running..'); System.out.println('Sum of two numbers is: '+ result); } public static void main( String args[] ) { // Creating instance of the class extend Thread class ThreadExample1 t1 = new ThreadExample1(); //calling start method to execute the run() method of the Thread class t1.start(); } } Uitgang:
Thread maken door de uitvoerbare interface te implementeren
In Java kunnen we ook een thread maken door de uitvoerbare interface te implementeren. De uitvoerbare interface biedt ons zowel de run()-methode als de start()-methode.
Laten we een voorbeeld nemen om te begrijpen hoe we de thread kunnen maken, starten en uitvoeren met behulp van de uitvoerbare interface.
ThreadVoorbeeld2.java
npm schone cache
class NewThread implements Runnable { String name; Thread thread; NewThread (String name){ this.name = name; thread = new Thread(this, name); System.out.println( 'A New thread: ' + thread+ 'is created
' ); thread.start(); } public void run() { try { for(int j = 5; j > 0; j--) { System.out.println(name + ': ' + j); Thread.sleep(1000); } }catch (InterruptedException e) { System.out.println(name + ' thread Interrupted'); } System.out.println(name + ' thread exiting.'); } } class ThreadExample2 { public static void main(String args[]) { new NewThread('1st'); new NewThread('2nd'); new NewThread('3rd'); try { Thread.sleep(8000); } catch (InterruptedException excetion) { System.out.println('Inturruption occurs in Main Thread'); } System.out.println('We are exiting from Main Thread'); } } Uitgang:
In het bovenstaande voorbeeld voeren we Multithreading uit door de uitvoerbare interface te implementeren. Voor meer informatie over multithreading, Klik hier .