Înainte de a introduce conceptul de fir , nu am putut rula mai mult de o sarcină în paralel. A fost un dezavantaj și pentru a elimina acest dezavantaj, Conceptul de fir a fost introdus.
A Fir este un proces foarte ușor, sau putem spune cea mai mică parte a procesului care permite unui program să funcționeze mai eficient, rulând mai multe sarcini simultan.
harta dactilografiată
Pentru a efectua sarcini complicate în fundal, am folosit Conceptul de fir în Java . Toate sarcinile sunt executate fără a afecta programul principal. Într-un program sau proces, toate firele de execuție au propria lor cale separată pentru execuție, astfel încât fiecare fir de execuție al unui proces este independent.
Un alt beneficiu al folosirii fir este că, dacă un thread primește o excepție sau o eroare în momentul execuției sale, nu afectează execuția celorlalte fire. Toate firele au o memorie comună și au propria lor stivă, variabile locale și contor de program. Când mai multe fire de execuție sunt executate în paralel în același timp, acest proces este cunoscut ca Multithreading .
Într-un mod simplu, un Thread este:
- Caracteristică prin care putem efectua mai multe activități în cadrul unui singur proces.
- Proces ușor.
- Serii de instrucțiuni executate.
- Secvență imbricată de apeluri de metodă.
Model de fir
La fel ca un proces, un fir există în mai multe state. Aceste stări sunt după cum urmează:
1) Nou (Gata de rulare)
Un fir este în Nou când primește timp CPU.
2) Alergarea
Un fir este în o Alergare starea când este în curs de execuție.
3) Suspendat
Un fir este în Suspendat stare când este temporar inactiv sau în curs de execuție.
4) Blocat
Un fir este în Blocat starea când așteaptă resurse.
5) Terminat
Un fir de execuție vine în această stare când, la un moment dat, își oprește imediat execuția.
hrithik roshan
Crearea Threadului
Un fir este creat fie prin „crearea sau implementarea” fișierului Interfață rulabilă sau prin extinderea Clasa de fire . Acestea sunt singurele două moduri prin care putem crea un fir.
Să ne aruncăm în detalii despre ambele modalități de a crea un fir:
Clasa de fire
A Clasa de fire are mai multe metode și constructori care ne permit să efectuăm diverse operații pe un fir. Clasa Thread extinde Obiect clasă. The Obiect clasa implementează Rugabil interfata. Clasa thread are următorii constructori care sunt utilizați pentru a efectua diverse operații.
Interfață rulabilă (metoda run())
Interfața Runnable trebuie să fie implementată de acea clasă ale cărei instanțe sunt destinate să fie executate de un fir. Interfața rulabilă ne oferă alerga() metodă de a efectua o acțiune pentru fir.
metoda start().
Metoda este folosită pentru a începe un thread pe care l-am creat recent. Începe un nou thread cu un nou callstack. După executarea start() metoda, firul de execuție schimbă starea de la New la Runnable. Ea execută metoda run(). când firul primește momentul corect pentru a-l executa.
Să luăm un exemplu pentru a înțelege cum putem crea un Java thread prin extinderea clasei Thread:
ThreadExample1.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(); } } Ieșire:
subșir de caractere java
Crearea firului prin implementarea interfeței rulabile
În Java, putem crea și un fir de execuție prin implementarea interfeței rulabile. Interfața rulabilă ne oferă atât metoda run() cât și metoda start().
Să luăm un exemplu pentru a înțelege cum putem crea, porni și rula firul folosind interfața rulabilă.
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'); } } Ieșire:
În exemplul de mai sus, efectuăm Multithreading prin implementarea interfeței rulabile. Pentru a afla mai multe despre Multithreading, click aici .