Millised probleemid võivad tekkida mitme lõimega töötamisel ja kuidas neid vältida?

Mitmed probleemid mitme lõimega töötamisel ja nende vältimise viisid:

• Andmepüünised (Data Race): tekivad, kui mitu lõime samaaegselt pääsevad ühistele andmetele ja vähemalt üks neist muudab neid andmeid. See võib põhjustada ettearvamatut käitumist ja ebaõigeid tulemusi.

  • Lahendus: kasutada sünkroniseerimismehhanisme nagu lock (Monitor), Mutex, Semaphore, ReaderWriterLockSlim, SpinLock.

  // Näide lock kasutamisest
  private object _lockObject = new object();
  private int _counter = 0;
  
  public void Increment()
  {
      lock (_lockObject)
      {
          _counter++; // Kriitiline sektsioon
      }
  }
  

• Võitlus (Deadlock): tekib, kui kaks või enam lõime on lukustatud, oodates ressursse, mida hoiab teine.

  • Lahendus:
    • vältida sisestatud lukustusi.
    • lukustusi saada eelnevalt määratletud järjekorras.
    • kasutada Monitor.TryEnter või Mutex.WaitOne(timeout) katsetamiseks lukustuse saamiseks ajapiiranguga.

• Nälgimine (Starvation): olukord, kus üks või mitu lõime ei saa pikka aega vajalikule ressursile (nt lukustusele) ligi, kuna teised lõimed neid pidevalt kasutavad.

  • Lahendus:
    • kasutada õiglasemaid (fair) sünkroniseerimismehhanisme (mitte kõik standardmehhanismid garanteerivad õiglust).
    • üle vaadata disain, võib-olla jagada suuremad kriitilised sektsioonid.
    • kasutada lõimupuhvreid õige prioriteedihaldamisega (kuigi prioriteetide muutmine võib põhjustada muid probleeme).

• Vale avalikustamine (Improper Publication): olukord, kus objekt muutub teistele lõimedele kättesaadavaks enne, kui tema konstruktor on täielikult lõppenud või enne, kui kõik tema väljad on õigesti initsialiseeritud.

  • Lahendus:
    • kasutada muutumatuid (immutable) objekte.
    • kasutada hilinenud initsialiseerimist koos lõimedele turvaliste mehhanismidega (Lazy<T>).
    • kasutada sünkroniseerimist objekti esimese avalikustamise ajal.

• Muutuste nähtamatud (Visibility Issues): muudatused, mille on teinud üks lõim, ei pruugi olla teistele lõimedele nähtavad kohe, kuna protsessori vahemälu või kompilaatori optimeerimised võivad takistada nende nähtavust.

  • Lahendus:
    • kasutada märksõna volatile muutujatele, millele pääseb ligi palju lõime (tagab, et lugemine võetakse alati mälust ja kirjutamine kirjutatakse mällu).
    • kasutada sünkroniseerimismehhanisme (lock, Monitor), mis hõlmavad mäluseinu.

  // Näide `volatile` kasutamisest
  private volatile bool _stopRequested = false;
  
  public void WorkerMethod()
  {
      while (!_stopRequested)
      {
          // Töö tegemine
      }
  }
  
  public void RequestStop()
  {
      _stopRequested = true;
  }
  

Probleemide ja lahenduste tabel:

Probleem	Kirjeldus	Lahendus
Andmepüünised	Üheaegne juurdepääs ühistele muudetavatele andmetele.	lock, Mutex, Semaphore, ReaderWriterLockSlim, SpinLock.
Kohaliku lukustamise	Lõimed ootavad ressursse, mida hoiab teine.	Vältida sisestatud, õigesti lukustada, kasutada ajapiiranguid.
Nälgimine	Lõim ei saa pikka aega juurdepääsu ressursile.	Õiglased sünkroniseerimismehhanismid, disaini ülevaatus, prioriteetide haldamine (ettevaatlikult).
Vale avalikustamine	Objekti kättesaadavus enne täielikku initsialiseerimist.	Muutumatud objektid, Lazy<T>, sünkroniseerimine avalikustamise ajal.
Nähtamatud muudatused	Ühe lõime tehtud muudatused ei ole teistele nähtavad kohe.	volatile, mäluseinad (sünkroniseerimismehhanismide kaudu).