logo

Multithreading în Java

  1. Multithreading
  2. Multifunctional
  3. Multitasking bazat pe proces
  4. Multitasking bazat pe fire
  5. Ce este Thread

Multithreading în Java este un proces de executare a mai multor fire simultan.

Un fir este un sub-proces ușor, cea mai mică unitate de procesare. Multiprocesare și multithreading, ambele sunt folosite pentru a realiza multitasking.

coarda inversată în c

Cu toate acestea, folosim multithreading decât multiprocessing, deoarece firele folosesc o zonă de memorie partajată. Nu alocă o zonă de memorie separată, așa că economisește memorie, iar comutarea contextului între fire durează mai puțin timp decât procesul.

Java Multithreading este folosit mai ales în jocuri, animații etc.


Avantajele Java Multithreading

1) Acesta nu blochează utilizatorul deoarece firele sunt independente și puteți efectua mai multe operații în același timp.

2) Tu poate efectua multe operații împreună, astfel încât economisiți timp .

3) Firele sunt independent , deci nu afectează alte fire dacă apare o excepție într-un singur fir.


Multifunctional

Multitasking este un proces de executare a mai multor sarcini simultan. Folosim multitasking pentru a folosi procesorul. Multitasking-ul poate fi realizat în două moduri:

  • Multitasking bazat pe proces (Multiprocesare)
  • Multitasking bazat pe fire (multithreading)

1) Multitasking bazat pe proces (Multiprocesare)

  • Fiecare proces are o adresă în memorie. Cu alte cuvinte, fiecare proces alocă o zonă de memorie separată.
  • Un proces este greu.
  • Costul de comunicare între proces este ridicat.
  • Trecerea de la un proces la altul necesită ceva timp pentru salvare și încărcare registre , hărți de memorie, liste de actualizare etc.

2) Multitasking bazat pe fire (multithreading)

  • Threadurile au același spațiu de adrese.
  • Un fir este ușor.
  • Costul de comunicare între fire este scăzut.

Notă: este necesar cel puțin un proces pentru fiecare fir.

Ce este Thread în java

Un fir este un subproces ușor, cea mai mică unitate de procesare. Este o cale separată de execuție.

Firele sunt independente. Dacă există o excepție într-un fir, aceasta nu afectează celelalte fire. Utilizează o zonă de memorie partajată.

Java Multithreading

După cum se arată în figura de mai sus, un fir este executat în interiorul procesului. Există o schimbare de context între fire. Pot exista mai multe procese în interiorul sistemului de operare și un proces poate avea mai multe fire de execuție.

Notă: La un moment dat este executat doar un fir.

Clasa Java Thread

Java oferă Clasa de fire pentru a realiza programarea firelor. Clasa de fire oferă constructorii și metode pentru a crea și a efectua operații pe un fir. Clasa de fire se extinde Clasa de obiecte și implementează interfața Runnable.

Metode Java Thread

S.N. Modificator și tip Metodă Descriere
1) gol start() Este folosit pentru a începe execuția firului.
2) gol alerga() Este folosit pentru a face o acțiune pentru un fir.
3) vid static dormi() Dorește un fir pentru perioada de timp specificată.
4) Fir static curent Thread() Returnează o referință la obiectul thread care se execută în prezent.
5) gol a te alatura() Așteaptă ca un fir să moară.
6) int getPriority() Returnează prioritatea firului de execuție.
7) gol stabilește prioritatea() Schimbă prioritatea firului.
8) Şir getName() Acesta returnează numele firului.
9) gol Pune un nume() Se schimbă numele firului.
10) lung getId() Returnează id-ul firului.
unsprezece) boolean este in viata() Testează dacă firul este viu.
12) vid static Randament() Determină o pauză a obiectului fir de execuție curent și permite altor fire să se execute temporar.
13) gol suspenda() Este folosit pentru suspendarea firului.
14) gol relua() Este folosit pentru a relua firul suspendat.
cincisprezece) gol Stop() Este folosit pentru a opri firul.
16) gol distruge() Este folosit pentru a distruge grupul de fire și toate subgrupurile sale.
17) boolean isDaemon() Testează dacă firul este un fir daemon.
18) gol setDaemon() Acesta marchează firul ca demon sau fir de utilizator.
19) gol întrerupe() Se întrerupe firul.
douăzeci) boolean este întreruptă() Testează dacă firul a fost întrerupt.
douăzeci și unu) boolean static întrerupt() Testează dacă firul curent a fost întrerupt.
22) static int activeCount() Returnează numărul de fire active din grupul de fire curent.
23) gol checkAccess() Acesta determină dacă firul care rulează în prezent are permisiunea de a modifica firul.
24) boolean static holdLock() Returnează adevărat dacă și numai dacă firul curent deține blocarea monitorului pe obiectul specificat.
25) vid static dumpStack() Este folosit pentru a imprima o urmă de stivă a firului de execuție curent în fluxul de erori standard.
26) StackTraceElement[] getStackTrace() Returnează o serie de elemente de urmărire a stivei reprezentând descărcarea stivei a firului de execuție.
27) static int enumera() Este folosit pentru a copia fiecare grup de fire active și subgrupul acestuia în matricea specificată.
28) Fire.State getState() Este folosit pentru a returna starea firului.
29) ThreadGroup getThreadGroup() Este folosit pentru a returna grupul de fire din care face parte acest thread
30) Şir toString() Este folosit pentru a returna o reprezentare șir a acestui fir, inclusiv numele firului, prioritatea și grupul de fire.
31) gol notifica() Este folosit pentru a da notificarea pentru un singur fir care așteaptă un anumit obiect.
32) gol notifyAll() Este folosit pentru a da notificarea tuturor firelor de execuție în așteptare ale unui anumit obiect.
33) gol setContextClassLoader() Setează contextul ClassLoader pentru Thread.
3. 4) ClassLoader getContextClassLoader() Returnează contextul ClassLoader pentru fir.
35) Thread static.UncaughtExceptionHandler getDefaultUncaughtExceptionHandler() Returnează handlerul implicit invocat atunci când un fir se termină brusc din cauza unei excepții neprinse.
36) vid static setDefaultUncaughtExceptionHandler() Setează handlerul implicit invocat atunci când un fir se termină brusc din cauza unei excepții neprinse.
Știi
  • Cum se efectuează două sarcini prin două fire?
  • Cum se efectuează multithreading prin clasă anonimă?
  • Ce este Thread Scheduler și care este diferența dintre programarea preventivă și time slicing?
  • Ce se întâmplă dacă începem un thread de două ori?
  • Ce se întâmplă dacă apelăm metoda run() în loc de metoda start()?
  • Care este scopul metodei join?
  • De ce JVM termină firul de execuție daemon dacă nu au mai rămas fire de execuție?
  • Ce este cârligul de închidere?
  • Ce este colectarea gunoiului?
  • Care este scopul metodei finalize()?
  • Ce înseamnă metoda gc()?
  • Ce este sincronizarea și de ce să folosiți sincronizarea?
  • Care este diferența dintre metoda sincronizată și blocul sincronizat?
  • Care sunt cele două moduri de a efectua sincronizarea statică?
  • Ce este blocajul și când poate apărea?
  • Ce este comunicarea între fire sau cooperarea?
Ce vom învăța în Multithreading
  • Multithreading
  • Ciclul de viață al unui fir
  • Două moduri de a crea un thread
  • Cum să efectuați mai multe sarcini prin mai multe fire
  • Programator de subiecte
  • Dormit un fir
  • Putem începe un thread de două ori?
  • Ce se întâmplă dacă apelăm metoda run() în loc de metoda start()?
  • Alăturarea unui fir
  • Denumirea unui fir
  • Prioritatea unui fir
  • Daemon Thread
  • ShutdownHook
  • Colectarea gunoiului
  • Sincronizare cu metoda sincronizata
  • Bloc sincronizat
  • Sincronizare statică
  • Impas
  • Comunicare între fire