multithreading java tutorial with examples
Aquest tutorial explica tot sobre Multithreading a Java, Implementació de simultaneïtat, el cicle de vida d'un fil, Exemple de classe de fils, Fil mitjançant interfície executable:
La concurrència al món de la informàtica és la capacitat d’un sistema (ja sigui aplicació, ordinador o llenguatge de programació) per executar diverses instàncies d’un programa o aplicació en paral·lel.
En executar instàncies o programes simultàniament, garantim un alt rendiment i un major rendiment, ja que podem utilitzar els recursos sense explotar, com el maquinari del sistema operatiu, etc. Per exemple, si un sistema té diverses CPU, l'aplicació pot utilitzar aquestes CPU amb eficàcia i augmentar el rendiment.
=> Visiteu aquí la sèrie exclusiva de cursos de formació de Java.
Què aprendreu:
- Què és el multithreading a Java
- Què és un fil a Java
- Conclusió
Què és el multithreading a Java
A Java, els fils es poden veure com la columna vertebral de la simultaneïtat. Un fil és una unitat executable i lleugera que accedeix a recursos compartits, així com a la seva pròpia pila de trucades.
Una aplicació Java és un procés i dins d’aquesta aplicació podem tenir diversos fils per aconseguir la simultaneïtat.
Sabem que una aplicació que s’executa al sistema pot tenir diverses instàncies i normalment s’anomenen aplicacions multidoc. Aquestes instàncies d'aplicació s'anomenen processos. A cadascun d'aquests processos se li assigna una unitat d'execució coneguda com a fil.
Depenent del sistema operatiu i dels requisits de l'aplicació, es pot assignar al procés un únic fil o diversos fils. Quan al procés d’aplicació se li assignen diversos fils, hem d’executar aquests fils múltiples simultàniament.
' Aquesta tècnica d’execució o execució de diversos fils simultàniament o simultàniament es coneix com a multithreading . '
Multithreading significa simplement que tenim més d’un fil executat dins de la mateixa aplicació.
El llenguatge de programació Java té suport integrat per a multiprocessament.
Multithreading es representa al diagrama anterior. Com es mostra, hi ha diversos fils que s’executen simultàniament dins d’una aplicació.
Per exemple, una aplicació d'escriptori que proporciona funcionalitats com l'edició, la impressió, etc. és una aplicació de diversos fils. En aquesta aplicació, com que la impressió és un procés de fons, podem editar documents i imprimir-los simultàniament assignant aquestes funcions a dos fils diferents.
Els fils de les aplicacions multitreades funcionen paral·lelament entre si de manera simultània. Per tant, el multithreading també és una part de la simultaneïtat a Java. Tingueu en compte que, tot i que hi ha diversos fils, comparteixen l'àrea de memòria per estalviar memòria. A més, els fils poden canviar de context fàcilment en poc temps.
El multithreading és útil sobretot, ja que proporciona una execució simultània de dues o més parts d’una aplicació. Això permet que l'aplicació utilitzi el temps de la CPU al màxim i el temps d'inactivitat es redueixi al mínim.
Els següents són alguns dels termes que hauríem de conèixer en relació amb l’entorn multithreading, ja que s’utilitzen amb freqüència.
Multitarea: En la multitarea, s’executen més d’una tasca al mateix temps.
Multithreading: Multithreading, com ja s’ha esmentat, és un procés d’execució de diversos fils simultàniament.
com extreure fitxers 7z al Mac
Multiprocessament: En el multiprocessament, s’executa més d’un procés simultàniament. Semblant a la multitarea, però aquí hi ha més d’una CPU.
Processament paral·lel: El processament en paral·lel és una tècnica en què múltiples CPU funcionen simultàniament en un sistema informàtic.
Després d’haver debatut sobre el multithreading, sorgeix la pregunta de per què necessitem el multithreading?
Avantatges de la multiprocessament
Multithreading té diversos avantatges que ajuden a una programació eficient.
Els punts següents ho deixaran clar.
# 1) Ús eficient de sistemes de CPU única
Quan només hi ha una CPU al sistema, amb un únic fil, es perd el temps de la CPU. Quan el fil està ocupat amb altres recursos com IO, la CPU està inactiva. Podem millorar-ho i utilitzar millor la CPU tenint aplicacions de múltiples fils.
Mitjançant l’ús de multithreading, si es fa un fil amb CPU, l’altre fil el pot utilitzar. Amb diversos fils, es reduirà molt el temps d'inactivitat de la CPU.
# 2) Ús eficient de múltiples sistemes de CPU
Igual que les CPU individuals, fins i tot amb sistemes que tinguin diverses CPU, les aplicacions de diversos fils poden utilitzar diverses CPU de manera eficient.
# 3) Millora de l’experiència de l’usuari respecte a la capacitat de resposta i l’equitat
La capacitat de resposta del sistema millora amb les aplicacions de múltiples fils. No experimentem el 'GUI penjat' quan tenim diversos fils que realitzen diverses tasques a l'aplicació i els usuaris no necessiten esperar molt de temps per obtenir una resposta a les seves sol·licituds.
De la mateixa manera, els usuaris són correctament serveis en sistemes multithread.
Com implementar la simultaneïtat a Java
La primera classe amb la qual podem implementar la simultaneïtat a Java és java.lang.Thread classe. Aquesta classe Thread constitueix la base de la simultaneïtat a Java.
També tenim java.lang.Runnable interfície que pot implementar una classe Java per abstraure el comportament del fil. Per al desenvolupament avançat d'aplicacions, podem fer ús del fitxer java.util.concurrent paquet disponible des de Java 1.5.
Per avançar, parlarem detalladament de la simultaneïtat a Java. Analitzem i entenem el concepte de fils a Java en aquest tutorial. En els nostres tutorials posteriors sobre multithreading, explorarem diversos conceptes de multithreading i simultaneïtat.
Què és un fil a Java
Un únic fil es pot definir com la unitat de processament més petita i lleugera. A Java, els fils s’utilitzen en programes que utilitzen la classe ‘Thread’.
Els fils Java són de dos tipus:
# 1) Fil de l'usuari: el fil de l'usuari es crea quan s'inicia l'aplicació per primera vegada. A continuació, podem crear tants fils d’usuaris i dimonis.
# 2) Fil del dimoni: els fils de dimoni s’utilitzen principalment en segon pla i s’utilitzen per a tasques com netejar l’aplicació, etc.
Els fils redueixen el cost de manteniment de l’aplicació. També redueix la sobrecàrrega de l’aplicació.
A continuació es mostra un exemple de fil únic:
public class Main{ public static void main (String () args){ System.out.println('This is a thread'); } } El programa anterior mostrarà 'Això és un fil' com quan s'inicia l'aplicació es crea un fil d'usuari. Al programa anterior, la funció principal és el punt de partida de l’aplicació i crea un fil d’usuari.
El cicle de vida d’un fil
El diagrama següent mostra el cicle de vida d'un fil a Java.
Com es mostra al diagrama anterior, un fil a Java té els estats següents:
# 1) Novetat: Inicialment, el fil acabat de crear a partir de la classe de fil té un estat 'nou'. Encara està per començar. També s’anomena aquest fil 'Fil nascut' .
# 2) Funcionable: En aquest estat, s’invoca la instància d’un fil mitjançant el mètode 'començar' .
# 3) Corrent: S'invoca el mètode d'inici de la instància de fil i el fil comença a executar-se. Aquest és l'estat de funcionament. Majoritàriament, el planificador planifica i gestiona els fils.
# 4) Bloquejat: Hi ha diversos fils en una aplicació. Aquests fils han d’esperar a un altre, ja que s’ha de sincronitzar la seva execució.
# 5) Finalitzat: Un cop finalitzat el procés d'execució del fil, el fil s'acaba o s'atura la seva execució.
Per tant, primer es crea un fil, després es programa i, posteriorment, el planificador l'executa. Tot i que el fil en execució es pot bloquejar o suspendre per alguna altra activitat. Després es reprèn i, mentre es completa el processament, s'executa el fil.
Prioritats del fil
Una prioritat de fil decideix com s’ha de tractar un fil respecte dels altres fils d’una aplicació. Una prioritat de fil és un nombre enter.
A continuació, es detallen alguns punts que cal recordar sobre les prioritats del fil:
- Les prioritats dels fils són nombres enters.
- Utilitzant la prioritat de fil, podem decidir quan hem de canviar d’un fil en estat d’execució a un altre. Aquest és el procés de commutació de context en el qual canviem de context dels fils.
- Sempre que un fil pot alliberar voluntàriament el seu control sobre la CPU. Aleshores, el fil amb la màxima prioritat es pot fer càrrec.
- De la mateixa manera, un fil de prioritat superior pot impedir qualsevol altre fil amb prioritat inferior.
- La classe de fil proporciona un mètode setPriority () que s’utilitza per establir la prioritat del fil.
- També podem utilitzar constants MIN_PRIORITY, MAX_PRIORITY o NORM_PRIORITY en lloc dels enters.
Crea un fil
Podem crear un fil utilitzant qualsevol de les maneres següents:
- Ampliant la classe ‘Thread’ de Java.
- Implementació de 'Runnable'.
S’estén la classe ‘Thread’ de Java
La classe 'Fil' conté els constructors i mètodes que ens permeten crear i realitzar operacions en un objecte de fil. Internament, la classe Thread implementa la interfície Runnable i també amplia la classe Object.
La taula següent proporciona un resum de diversos constructors i mètodes d'una classe Thread ().
| constructor / | Prototip | Descripció |
|---|---|---|
| dormir | son públic buit (mil·lisegons llargs) | L'execució del fil actual s'atura durant uns mil·lisegons especificats. |
| Thread () constructor | Fil () | Constructor per defecte per crear un objecte Thread. |
| Fil (nom de la cadena) | Constructor per crear un objecte Thread amb el nom especificat. | |
| Fil (r executable) | Creeu una instància de fil amb l'objecte d'interfície Runnable especificat. | |
| Fil (r executable, nom de la cadena) | Creeu una instància de fil amb l'objecte d'interfície Runnable especificat i el nom donat | |
| correr | public void run () | El mètode Run realitza l'acció d'un fil. Invoca el fil. |
| començar | public void start () | S'utilitza per iniciar l'execució del fil. Internament, el mètode de les trucades JVM run () en aquest fil. |
| unir-se | public void join () | Espereu que el fil es mori |
| unió pública de buit (mil·lisegons llargs) | Espereu els mil·lisegons especificats perquè el fil mori. | |
| getPriority | public int getPriority () | Retorna la prioritat del fil |
| setPriority | public int setPriority (prioritat int) | Canvieu la prioritat del fil a la prioritat especificada |
| getName | public String getName () | torna el nom del fil. |
| setName | public void setName (nom de la cadena) | Establiu el nom del fil a la cadena especificada |
| currentThread | Fil públic currentThread () | Retorna la referència del fil que està actualment actiu |
| getId | public int getId () | Torna l'identificador del fil |
| getState () | Thread.State públic getState () | Retorna l'estat actual del fil |
| està viu | isAlive booleà públic () | Comproveu si el fil està viu i torneu a ser cert si sí. |
| rendiment | rendiment del buit públic () | Atura temporalment el fil actual i permet executar altres fils. |
| isDaemon | boolean públic isDaemon () | Comproveu si el fil és un fil de dimoni; torna cert si és així. |
| setDaemon | public void setDaemon (booleà b) | Establiu el fil com a fil de dimoni si b = true; altrament establert com a fil d'usuari. |
| interrompre | interrupció de buit públic () | Interrompre el fil actual. |
| isInterrupted | booleà públic isInterrupted () | Comproveu si el fil està interromput. |
| interromput | booleà estàtic públic interromput () | Comproveu si el fil actual s'ha interromput. |
| dumpStack | Static void dumpStack () | Imprimeix una traça de pila del fil actual al flux d'error estàndard. |
| suspendre | public void suspend () | Suspèn tots els fils. (El mètode ** està obsolet a les darreres versions de Java) |
| resum | public void resume () | Reprendre el fil suspès. (El mètode ** està obsolet a les darreres versions de Java) |
| Atura | public void stop () | Atura el fil. (El mètode ** està obsolet a les darreres versions de Java) |
Detallarem aquests mètodes de fils en el nostre proper tutorial sobre multithreading.
Començar un fil
El mètode start () que s'utilitza per iniciar el fil segueix els passos següents:
- Inicia una nova instància de fil amb un CallStack nou.
- L'estat del fil passa de nou a executable.
- Quan és el torn del fil, executa el mètode run ().
Implementació de la interfície ‘Runnable’
També es pot crear una instància de fil mitjançant la interfície Runnable. Per crear una instància de fil, la classe els objectes de la qual hauria de ser executada hauria d'implementar la interfície Runnable.
La interfície Runnable només té un mètode:
public void run () => this method is used to execute the thread. Exemple de classe de fils
Ara demostrem el fil a Java mitjançant la classe de fil.
//class inherited from 'Thread' class ThreadClassDemo extends Thread { private int number; //class constructor public ThreadClassDemo(int number) { this.number = number; } //run method => execution code for thread public void run() { int counter = 0; int numInt = 0; //prints the number till specified number is reached, starting from 10 do { numInt = (int) (counter + 10); System.out.println(this.getName() + ' prints ' + numInt); counter++; } while(numInt != number); System.out.println('** Correct! ' + this.getName() + 'printed ' + counter + ' times.**'); } } public class Main { public static void main(String () args) { System.out.println('Starting thread_1...'); //create a thread class instance Thread thread_1 = new ThreadClassDemo(15); //start the thread thread_1 thread_1.start(); try { //wait for thread_1 to die thread_1.join(); } catch (InterruptedException e) { System.out.println('Thread interrupted.'); } System.out.println('Starting thread_2...'); Thread thread_2 = new ThreadClassDemo(20); //start thread_2 thread_2.start(); System.out.println('main() is ending...'); } } Sortida
Fil de Java mitjançant la interfície executable
L'exemple següent mostra l'ús de la interfície Runnable per crear una instància de fil.
//class implements Runnable interface class RunnableDemo implements Runnable { private String message; //class constructor public RunnableDemo(String message) { this.message = message; } //run method public void run() { while(true) { System.out.println(message); } } } public class Main { public static void main(String () args) { //create first thread instance hello Runnable hello = new RunnableDemo('Hello, Greetings!!!'); Thread thread1 = new Thread(hello); thread1.setDaemon(true); //set this thread as daemon thread1.setName('hello'); System.out.println('Starting First thread...'); //start the thread thread1.start(); //create second thread instance bye Runnable bye = new RunnableDemo('Bye for now!!'); Thread thread2 = new Thread(bye); thread2.setPriority(Thread.MIN_PRIORITY); //set priority to min thread2.setDaemon(true); //set as daemon thread System.out.println('Starting goodbye thread...'); //start the thread thread2.start(); System.out.println('main() is ending...'); } }Sortida
Com aturar un fil a Java
Hem vist els exemples de fils anteriors. A partir d'aquests exemples, sabem que quan el mètode d'execució acaba l'execució, el fil s'atura o també s'atura a causa d'algunes excepcions.
Les versions anteriors de Java tenien un mètode stop () a la classe Thread que es podia utilitzar per aturar directament el fil. Però ara ha quedat obsolet per motius de seguretat. Per tant, hem d’emprar els altres mètodes per aturar el fil que s’està executant.
Hi ha dos mètodes que podem utilitzar per aturar el fil.
- Utilització d’una variable booleana volàtil
- Ús d’interrupcions.
En aquesta secció, discutirem aquests dos mètodes per aturar un fil.
Utilització d’una variable booleana volàtil
En aquest mètode, mantenim una variable booleana per exemple flag, per aturar el fil. El fil s’executa sempre que la variable booleana estigui establerta en true. En el moment que es fa fals, el fil s’atura.
L’especialitat d’aquest mètode és que declarem la variable booleana com a “ volàtil ”, De manera que sempre es llegeix des de la memòria principal i el programa no el pot emmagatzemar a la memòria cau de la CPU. D'aquesta manera, no hi haurà cap diferència en els valors establerts i llegits.
A continuació es mostra la implementació d’aturar un fil mitjançant una variable booleana volàtil.
class StopThread extends Thread { private volatile boolean stop_flag = true; //initially set to true public void stopRunning() { stop_flag = false; //set stop_flag to false } @Override public void run() { while (stop_flag) { //keep checking value of stop_flag System.out.println('Thread is running...'); } System.out.println('Thread stopped!!!'); } } public class Main { public static void main(String() args) { //create a thread instance StopThread stop_thread = new StopThread(); //start the thread stop_thread.start(); try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } //call stopRunning() method to stop the thread stop_thread.stopRunning(); } } Sortida
Nota: Aquí només hem mostrat una part de la sortida. El fil pot funcionar diversos minuts abans d’aturar-se. De manera que podem obtenir diferents resultats en diferents sistemes.
Ús d’interrupcions
Aquí el fil es para amb el mètode interrupt () com ja hem comentat anteriorment en els mètodes de classe de fils. El mètode interrupt () estableix l'estat del fil com a interromput. Aquest estat es passa al bucle while del mètode run (). Podem obtenir l’estat d’interrupció mitjançant el mètode interrupted ().
El programa següent mostra l'ús del mètode interrupt () per aturar el fil.
etapes del cicle de vida del desenvolupament de programari
class StopThread extends Thread { @Override public void run() { while (!Thread.interrupted()) { //check for interrupted status System.out.println('Thread is running...'); } System.out.println('Thread stopped!!!'); } } public class Main { public static void main(String() args) { //create a thread instance StopThread stop_thread = new StopThread(); //start the thread stop_thread.start(); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } //interrupt the thread stop_thread.interrupt(); } } Sortida
Preguntes freqüents
P # 1) Per què fem servir Multithreading a Java?
Resposta: Multithreading permet l'execució simultània o simultània de dos o més fils en una aplicació. L'execució simultània maximitza el rendiment i també utilitza la CPU al màxim.
P # 2) Què és Multithreading? Quins són els seus tipus?
Resposta: Multithreading significa executar més d’un fil. Aquesta execució pot ser simultània o paral·lela. Per tant, el multithreading té dos tipus, és a dir, simultani o paral·lel.
P # 3) Què és Multithreading vs. Multiprocessing?
Resposta: En el multithreading, hi ha múltiples fils per al mateix o diferents processos i aquests fils s’executen simultàniament per millorar la velocitat de càlcul d’un sistema. En el processament múltiple, un sistema té més de dues CPU i s’executen múltiples processos simultàniament.
Q # 4) Quins avantatges té Multithreading a Java?
Resposta: Mitjançant el multithreading podem executar diferents parts d’una aplicació simultàniament mitjançant fils. El multithreading augmenta el rendiment del sistema. El multithreading també maximitza la utilització de la CPU ja que diferents fils utilitzen contínuament la CPU.
P # 5) El Multithreading és bo per als jocs?
Resposta: Sí, sobretot per als jocs moderns.
Conclusió
Tot es tracta de la introducció del multithreading. En aquest tutorial hem parlat de la simultaneïtat i el multi-threading a Java. Vam discutir la creació d’un fil amb la classe Thread, així com la interfície Runnable, i hem proporcionat els exemples adequats.
També hem après els conceptes d’un sol fil i la seva creació en detall. Els conceptes de fil que inclouen el cicle de vida d'un fil, aturar un fil, tipus de fil, etc. s'han discutit en aquest tutorial.
També vàrem parlar de multithreading a llarg termini i simultaneïtat a Java. Al final d’aquest tutorial, el lector hauria de ser capaç d’entendre fàcilment els conceptes de simultaneïtat i multithreading i també els fils a Java.
=> Mireu aquí les sèries de formació Java senzilles.
Lectura recomanada
- Multithreading en C ++ amb exemples
- Fils de Java amb mètodes i cicle de vida
- Thread.Sleep (): mètode Thread Sleep () a Java amb exemples
- Tutorial JAVA per a principiants: més de 100 tutorials pràctics de vídeo Java
- Tutorial de reflexió de Java amb exemples
- Java String conté () Tutorial de mètode amb exemples
- Matriu irregular a Java: tutorial amb exemples
- Tutorial de classe Java Scanner amb exemples