Diferència clau: dormir vs esperar a Java
Dormir i esperar són dos mètodes que s'utilitzen per fer multiprocés a Java. El mètode sleep pertany a la classe Thread mentre que el mètode wait és de la classe Object. La diferència clau entre sleep i wait a Java és que el sleep s'utilitza per suspendre l'execució del fil actual durant el nombre especificat de mil·lisegons mentre que el mètode wait s'utilitza per fer que el fil actual s'esperi fins que un altre fil invoqui la notificació o mètode notifyAll per a l'objecte.
Un fil és la unitat de processament més petita del sistema operatiu. És un únic flux seqüencial de control dins d'un programa. Els fils són lleugers. El multithreading és el mecanisme d'executar diversos fils al mateix temps. Els llenguatges de programació com Java admeten multithreading. El multithreading té avantatges perquè permet executar múltiples fils simultàniament i els fils són independents els uns dels altres. Hi ha mètodes en Java que es poden utilitzar per multithreading. Dos d'ells dormen i esperen.
Què és el somni a Java?
Hi ha diversos processos en execució en un sistema operatiu. Un procés és un programa en execució. Cada procés pot tenir diversos fils i hi ha un canvi de context entre aquests fils. A Java, hi ha dues maneres de crear un fil. Això és ampliant la classe de fil o implementant la interfície Runnable. La classe Thread té constructors i mètodes per crear i realitzar operacions en un fil. La classe Thread amplia la classe Object i implementa la interfície Runnable. La interfície Runnable ha de ser implementada per qualsevol classe les instàncies de la qual estiguin destinades a ser executades per un fil. Quan el fil s'executa, el codi que s'ha d'executar s'escriu dins del mètode d'execució. El programador de fils selecciona el fil que s'ha d'executar. Només s'executa un fil en un sol procés.
Un fil passa per diverses fases. Després de crear un objecte de la classe Thread, el programador pot invocar el mètode d'inici. Abans d'invocar aquest mètode, es diu que el fil està en el nou estat. El programador de fils selecciona un fil per executar-lo. Si el programador de fils encara no ha seleccionat el fil però si s'invoca el mètode d'inici, llavors el fil està en un estat executable. Després que el programador de fils selecciona el fil per executar, passa a l'estat d'execució. Si el fil està viu, però actualment no és apte per executar-se, aleshores es troba en estat no executable o bloquejat. Un cop finalitzat el mètode d'execució, el fil passa a l'estat final. Aquestes són les fases principals del cicle de vida del fil.
Hi ha diversos mètodes disponibles a la classe de fil per realitzar diferents tasques. El mètode sleep s'utilitza per dormir el mètode durant un període de temps específic. La sintaxi per al mètode de repòs és la repòs pública nul (mil·lisegons llargs) que genera InterruptedException. Fa que el fil que s'executa actualment atura l'execució temporalment durant un nombre especificat de mil·lisegons. Si un altre fil interromp el fil actual, l'estat interromput del fil actual s'esborra quan es llança aquesta excepció.
Figura 01: Programa Java amb mètode de repòs
Segons el programa anterior, el mètode d'execució conté codi que s'ha d'executar. Al programa principal, es creen dos objectes de l'ExampleThread1 i s'hi invoquen els mètodes d'inici. Això permetrà executar el codi dins del mètode d'execució. Només s'executa un fil alhora. Amb el Fil.dormir (1000); permetrà que el primer fil finalitzi l'execució durant 1000 mil·lisegons. Quan un fil està en repòs, el programador de fils agafa l' altre fil.
Què és esperar a Java?
Varis fils poden accedir a un recurs compartit. Pot provocar que es generi una sortida incorrecta. La sincronització de fils es pot utilitzar per fer només un fil per accedir al recurs compartit. Suposem una situació de la següent manera. Si hi ha dos fils com t1 i t2, t1 començarà a desar valors en un fitxer de text anomenat Text1.txt. Aquests valors s'utilitzaran per a algun altre càlcul quan torni t1. Si t2 comença abans que torni t1, t2 pot canviar els valors desats per t1. Això pot fer que t1 proporcioni una sortida incorrecta. Amb l'ajuda de la sincronització, quan t1 comença a utilitzar el fitxer Text1.txt, aquest fitxer es pot bloquejar, de manera que només t1 pot accedir-hi. El t2 no pot canviar-lo fins que t1 alliberi el bloqueig per accedir a aquest fitxer de text. Quan s'hagi completat la tasca, el t1 pot alliberar el bloqueig. El pany també es coneix com a monitor.
La sincronització de fils es pot aconseguir mitjançant la comunicació entre fils. Una secció crítica és un segment de codi que accedeix als recursos compartits. En la comunicació entre fils, un fil es posa en pausa en execució a la seva secció crítica i es permet que un altre fil entri a la mateixa secció crítica per ser executat. S'implementa mitjançant els mètodes wait, notify i notifyAll. Pertanyen a la classe Object. El mètode wait s'utilitza per permetre que el fil actual alliberi el bloqueig i espere fins que un altre fil invoqui el mètode notify o notifyAll per a l'objecte. El mètode de notificació s'utilitza per despertar un sol fil que està esperant el bloqueig. NotifyAll activa tots els fils que estan esperant al bloqueig.
Figura 02: classe de calculadora
Figura 03: Mètode principal
La classe de la calculadora amplia el fil. El bloc sincronitzat es troba dins del mètode d'execució. El mètode for loop i notify es troba dins del bloc sincronitzat. Dins del mètode principal, es crea una instància d'un fil i es crida al mètode d'inici en aquesta instància. El mètode principal esperarà fins que el fil doni una notificació. Quan s'executa el programa, el mètode principal espera fins a l'execució completa del mètode d'execució i espera el mètode de notificació. Un cop cridat al mètode de notificació, el mètode principal deixa d'esperar i comença a executar la resta del codi. Main està esperant fins que s'hagi completat el fil de la calculadora. Finalment, s'imprimeix el resultat de la suma.
Si no hi ha cap bloc sincronitzat i si el mètode principal té un codi com el següent, donarà la sortida com a zero perquè no està esperant que es completi l' altre fil.
Calculadora t1=calculadora nova ();
t1. començar ();
System.out.println (t1.sum);
Quina semblança hi ha entre dormir i esperar a Java?
Tant el repòs com l'espera són mètodes que es poden utilitzar quan s'implementa multithreading a Java
Quina diferència hi ha entre dormir i esperar a Java?
dorm vs espera a Java |
|
| El mètode de repòs fa que el fil actual se suspengui l'execució durant el nombre especificat de mil·lisegons, subjecte a la precisió i la precisió dels temporitzadors i programadors del sistema. | El mètode wait fa que el fil actual s'esperi fins que un altre fil invoqui el mètode notify o notifyAll per a l'objecte. |
| Associació amb el bloqueig | |
| El mètode de repòs no allibera el bloqueig d'un objecte durant la sincronització. | El mètode d'espera allibera el bloqueig durant la sincronització. |
| Mètode d'execució | |
| El mètode de repòs s'executa al fil actual. | El mètode d'espera es crida a l'objecte. |
| Classe associada | |
| El somni és un mètode de classe Thread. | L'espera és un mètode de classe d'objectes. |
| Finalització | |
| El procés de repòs s'ha completat un cop finalitzat el període de temps especificat. | El mètode d'espera s'interromp trucant a notify o notifyAll. |
Resum: dormir vs esperar a Java
Hi ha diversos processos en execució al sistema operatiu. Cada procés pot tenir diversos fils. Un fil és la unitat de processament més petita d'un sistema operatiu. El llenguatge de programació Java admet multithreading. Permet executar diversos fils simultàniament. El somni i l'espera són dos mètodes que es poden utilitzar quan s'implementa el multiprocés. La diferència entre sleep i wait a Java és que el sleep s'utilitza per suspendre l'execució del fil actual durant el nombre especificat de mil·lisegons mentre que el mètode wait s'utilitza per fer que el fil actual s'esperi fins que un altre fil invoqui la notificació o notifyAll. mètode per a l'objecte.
