Abans de presentar el concepte de fil , no hem pogut executar més d'una tasca en paral·lel. Va ser un inconvenient, i per eliminar aquest inconvenient, Concepte de fil es va presentar.
A Fil és un procés molt lleuger, o podem dir la part més petita del procés que permet que un programa funcioni de manera més eficient executant múltiples tasques simultàniament.
exemple de mapa java
Per tal de realitzar tasques complicades en segon pla, hem utilitzat Concepte de fil en Java . Totes les tasques s'executen sense afectar el programa principal. En un programa o procés, tots els fils tenen la seva pròpia ruta d'execució, de manera que cada fil d'un procés és independent.
Un altre avantatge d'utilitzar fil és que si un fil rep una excepció o un error en el moment de la seva execució, no afecta l'execució dels altres fils. Tots els fils comparteixen una memòria comuna i tenen la seva pròpia pila, variables locals i comptador de programa. Quan s'executen diversos fils en paral·lel al mateix temps, aquest procés es coneix com Multithreading .
D'una manera senzilla, un fil és:
- Característica mitjançant la qual podem realitzar múltiples activitats dins d'un sol procés.
- Procés lleuger.
- Sèrie de declaracions executades.
- Seqüència imbricada de trucades de mètodes.
Model de fil
Igual que un procés, un fil existeix en diversos estats. Aquests estats són els següents:
1) Nou (a punt per funcionar)
Hi ha un fil Nou quan tingui temps de CPU.
2) Córrer
Hi ha un fil una Córrer estat quan està en execució.
3) Suspès
matriu dinàmica java
Hi ha un fil Suspès estat quan està temporalment inactiu o en execució.
4) Bloquejat
Hi ha un fil Bloquejat estat quan està esperant recursos.
5) Finalitzat
Un fil arriba en aquest estat quan, en un moment donat, atura la seva execució immediatament.
Creació de fil
Es crea un fil 'creant o implementant' el fitxer Interfície executable o ampliant el Classe de fil . Aquestes són les dues úniques maneres a través de les quals podem crear un fil.
Aprofundim en els detalls d'aquestes dues maneres de crear un fil:
Classe de fil
A Classe de fil té diversos mètodes i constructors que ens permeten realitzar diverses operacions en un fil. La classe Thread amplia el Objecte classe. El Objecte la classe implementa el Es pot executar interfície. La classe de fil té els constructors següents que s'utilitzen per realitzar diverses operacions.
repl en java
Interfície executable (mètode run())
La interfície Runnable ha de ser implementada per aquella classe les instàncies de la qual estan destinades a ser executades per un fil. La interfície executable ens ofereix correr() mètode per realitzar una acció per al fil.
mètode start().
El mètode s'utilitza per iniciar un fil que hem creat recentment. Inicia un fil nou amb una nova pila de trucades. Després d'executar el començar() mètode, el fil canvia l'estat de Nou a Executable. Executa el mètode run(). quan el fil aconsegueix el moment correcte per executar-lo.
Prenguem un exemple per entendre com podem crear un Java fil ampliant la classe 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(); } } Sortida:
Creació de fil mitjançant la implementació de la interfície executable
A Java, també podem crear un fil mitjançant la implementació de la interfície executable. La interfície executable ens proporciona tant el mètode run() com el mètode start().
Prenem un exemple per entendre com podem crear, iniciar i executar el fil mitjançant la interfície executable.
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'); } } Sortida:
A l'exemple anterior, realitzem el Multithreading implementant la interfície executable. Per obtenir més informació sobre Multithreading, clica aquí .