Ieșire din consolă: eu sunt Thread! Numele meu este Thread-2 Sunt Thread!

Numele
meu este Thread-1 Sunt Thread! Numele meu este Thread-0 Sunt Thread! Numele meu
este Thread-3 Sunt Thread! Numele meu este Thread-6 Sunt Thread! Numele meu este
Thread-7 Sunt Thread! Numele meu este Thread-4 Sunt Thread! Numele meu este Thread-
5 Sunt Thread! Numele meu este Thread-9, sunt Thread! Numele meu este Thread-8 Să
creăm 10 fire ( obiecte MyFirstThread , care moștenesc Thread ) și să le începem
apelând metoda start() pe fiecare obiect. După apelarea metodei start() , este
executată logica metodei run() . Notă: numele firelor nu sunt în ordine. Este
ciudat că nu au fost secvenţial:, Thread-1 , Thread-2 și așa mai departe? După cum
se întâmplă, acesta este un exemplu de moment în care gândirea „secvențială” nu se
potrivește. Problema este că am furnizat doar comenzi pentru a crea și a rula 10
fire. Planificatorul de fire, un mecanism special al sistemului de operare, decide
ordinea lor de execuție. Designul său precis și strategia de luare a deciziilor
sunt subiecte pentru o discuție profundă în care nu ne vom arunca acum. Principalul
lucru de reținut este că programatorul nu poate controla ordinea de execuție a
firelor. Pentru a înțelege gravitatea situației, încercați să rulați metoda main()
din exemplul de mai sus de câteva ori. Ieșire din consolă la a doua rulare: Eu sunt
Thread! Numele meu este Thread-0 Sunt Thread! Numele meu este Thread-4 Sunt Thread!
Numele meu este Thread-3 Sunt Thread! Numele meu este Thread-2 Sunt Thread! Numele
meu este Thread-1 Sunt Thread! Numele meu este Thread-5 Sunt Thread! Numele meu
este Thread-6 Sunt Thread! Numele meu este Thread-8 Sunt Thread! Numele meu este
Thread-9, sunt Thread! Numele meu este Thread-7 Console ieșire din a treia rulare:
Sunt Thread! Numele meu este Thread-0 Sunt Thread! Numele meu este Thread-3 Sunt
Thread! Numele meu este Thread-1 Sunt Thread! Numele meu este Thread-2 Sunt Thread!
Numele meu este Thread-6 Sunt Thread! Numele meu este Thread-4 Sunt Thread! Numele
meu este Thread-9, sunt Thread! Numele meu este Thread-5 Sunt Thread! Numele meu
este Thread-7 Sunt Thread! Numele meu este Thread-8
Probleme create de multithreading
În exemplul nostru cu cărți, ați văzut că multithreading rezolvă sarcini foarte
importante și poate face programele noastre mai rapide. Adesea de multe ori mai
repede. Dar multithreading-ul este considerat a fi un subiect dificil. Într-adevăr,
dacă este folosit necorespunzător, creează probleme în loc să le rezolve. Când spun
„creează probleme”, nu mă refer într-un sens abstract. Există două probleme
specifice pe care le poate crea multithreading: blocaj și condiții de cursă.
Deadlock este o situație în care mai multe fire așteaptă resurse deținute unul de
celălalt și niciunul dintre ele nu poate continua să ruleze. Vom vorbi mai multe
despre asta în lecțiile ulterioare. Următorul exemplu va fi suficient deocamdată:
Multithreading în Java: ce este, beneficiile sale și capcanele comune -
4Imaginează-ți că Thread-1 interacționează cu un obiect-1 și că Thread-2
interacționează cu Object-2. În plus, programul este scris astfel încât:

Thread-1 încetează să interacționeze cu Object-1 și trece la Object-2 de îndată

ce Thread-2 încetează să interacționeze cu Object-2 și trece la Object-1.
Thread-2 încetează să interacționeze cu Object-2 și trece la Object-1 de îndată
ce Thread-1 încetează să interacționeze cu Object-1 și trece la Object-2.

Chiar și fără o înțelegere profundă a multithreading-ului, puteți vedea cu ușurință

că nu se va întâmpla nimic. Firele nu vor schimba niciodată locurile și se vor
aștepta pentru totdeauna. Eroarea pare evidentă, dar în realitate nu este. Puteți
face acest lucru cu ușurință într-un program. Vom lua în considerare exemple de cod
care provoacă blocaj în lecțiile ulterioare. Apropo, Quora are un exemplu grozav
din viața reală care explică ce impaseste. „În unele state din India, nu vă vor
vinde terenuri agricole decât dacă sunteți fermier înregistrat. Cu toate acestea,
nu te vor înregistra ca fermier dacă nu deții teren agricol'. Grozav! Ce putem
spune?! :) Acum să vorbim despre condițiile de cursă. O condiție de cursă este o
eroare de proiectare într-un sistem sau o aplicație cu mai multe fire, în care
funcționarea sistemului sau a aplicației depinde de ordinea în care sunt executate
părțile codului. Amintiți-vă, exemplul nostru în care am început firele:
public class MyFirstThread extends Thread {

@Override
public void run() {
System.out.println("Thread executed: " + getName());
}
}

public class Main {

public static void main(String[] args) {

for (int i = 0; i < 10; i++) {

MyFirstThread thread = new MyFirstThread();

thread.start();
}
}
}

Acum imaginați-vă că programul este responsabil pentru rularea unui robot care
gătește mâncare! Thread-0 scoate ouăle din frigider. Thread-1 pornește aragazul.
Thread-2 primește o tigaie și o pune pe aragaz. Thread-3 aprinde aragazul. Firul-4
toarnă ulei în tigaie. Firul-5 rupe ouăle și le toarnă în tigaie. Thread-6 aruncă
cojile de ouă în coșul de gunoi. Thread-7 scoate ouăle fierte din arzător. Firul-8
pune ouăle fierte pe o farfurie. Thread-9 spală vasele. Uită-te la rezultatele
programului nostru: Fire executată: Fire-0 Fire executată: Thread-2 Thread
executată Thread-1 Thread executat: Thread-4 Thread executat: Thread-9 Thread
executat: Thread-5 Thread executat: Thread-8 Thread executat: Thread-7 Thread
executat: Thread-3 Este aceasta o rutină de comedie? :) Și totul pentru că munca
programului nostru depinde de ordinea de execuție a firelor. Având în vedere cea
mai mică încălcare a secvenței necesare, bucătăria noastră se transformă în iad,
iar un robot nebun distruge totul în jurul ei. Aceasta este, de asemenea, o
problemă comună în programarea cu mai multe fire. Veți auzi despre asta de mai
multe ori. În încheierea acestei lecții, aș dori să recomand o carte despre
multithreading.