Prima di introdurre il concetto di filo , non siamo riusciti a eseguire più di un'attività in parallelo. Era uno svantaggio, e per eliminare quell'inconveniente, Concetto di filo è stato presentato.

UN Filo è un processo molto leggero, o possiamo dire la parte più piccola del processo che consente a un programma di operare in modo più efficiente eseguendo più attività contemporaneamente.

Neena Gupta

Per eseguire compiti complicati in background, abbiamo utilizzato il file Il concetto di thread in Java . Tutte le attività vengono eseguite senza influenzare il programma principale. In un programma o processo, tutti i thread hanno il proprio percorso separato per l'esecuzione, quindi ogni thread di un processo è indipendente.

Un altro vantaggio dell'utilizzo filo è che se un thread riceve un'eccezione o un errore al momento della sua esecuzione, ciò non influisce sull'esecuzione degli altri thread. Tutti i thread condividono una memoria comune e hanno il proprio stack, variabili locali e contatore di programma. Quando più thread vengono eseguiti in parallelo contemporaneamente, questo processo è noto come Multithreading .

In un modo semplice, un thread è un:

• Funzionalità attraverso la quale possiamo eseguire più attività all'interno di un unico processo.
• Processo leggero.
• Serie di dichiarazioni eseguite.
• Sequenza nidificata di chiamate di metodo.

Modello di filettatura

Proprio come un processo, un thread esiste in diversi stati. Questi stati sono i seguenti:

1) Nuovo (pronto per l'uso)

C'è un thread Nuovo quando arriva il tempo della CPU.

2) Correre

C'è un thread una corsa stato quando è in esecuzione.

3) Sospeso

C'è un thread in Sospeso stato quando è temporaneamente inattivo o in esecuzione.

4) Bloccato

C'è un thread in Bloccato stato quando è in attesa di risorse.

5) Terminato

Un thread si trova in questo stato quando, in qualsiasi momento, interrompe immediatamente la sua esecuzione.

Creazione discussione

Un thread viene creato 'creando o implementando' il file Interfaccia eseguibile o estendendo il Classe del thread . Questi sono gli unici due modi attraverso i quali possiamo creare un thread.

Entriamo nei dettagli di entrambi questi modi di creare un thread:

elimina l'ultimo commit git

Classe discussione

UN Classe del thread ha diversi metodi e costruttori che ci permettono di eseguire varie operazioni su un thread. La classe Thread estende il file Oggetto classe. IL Oggetto la classe implementa il file Percorribile interfaccia. La classe thread dispone dei seguenti costruttori utilizzati per eseguire varie operazioni.

Filo() Thread (eseguibile, nome stringa) Thread (destinazione eseguibile) Thread (gruppo ThreadGroup, destinazione eseguibile, nome stringa) Thread (gruppo ThreadGroup, destinazione eseguibile) Thread(gruppo ThreadGroup, nome stringa) Thread (gruppo ThreadGroup, destinazione eseguibile, nome stringa, dimensione stack lungo)

Interfaccia eseguibile (metodo run())

L'interfaccia Runnable deve essere implementata da quella classe le cui istanze devono essere eseguite da un thread. L'interfaccia eseguibile ci fornisce il file correre() metodo per eseguire un'azione per il thread.

metodo start()

Il metodo viene utilizzato per avviare un thread che abbiamo appena creato. Inizia un nuovo thread con un nuovo stack di chiamate. Dopo aver eseguito il inizio() metodo, il thread cambia lo stato da New a Runnable. Esegue il metodo run() quando il thread ottiene il momento giusto per eseguirlo.

Facciamo un esempio per capire come possiamo creare un Giava thread estendendo la classe Thread:

DiscussioneEsempio1.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(); } } 

Produzione:

Creazione del thread implementando l'interfaccia eseguibile

In Java possiamo anche creare un thread implementando l'interfaccia eseguibile. L'interfaccia eseguibile ci fornisce sia il metodo run() che il metodo start().

Facciamo un esempio per capire come possiamo creare, avviare ed eseguire il thread utilizzando l'interfaccia eseguibile.

sottostringa della stringa Java

ThreadExample2.java

 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'); } } 

Produzione:

Nell'esempio sopra, eseguiamo il multithreading implementando l'interfaccia eseguibile. Per saperne di più sul multithreading, clicca qui .