Nima uchun iplar poygaslari yuzaga keladi va ularga…

Yugurish shartlari (race conditions) bir nechta oqimlar bir vaqtning o'zida umumiy o'zgartiriladigan ma'lumotlarga murojaat qilganda yuzaga keladi va natija ularning bajarilish tartibiga bog'liq bo'ladi. Bu, operatsion tizim har qanday vaqtda oqimlarni almashtirishi va ularning bajarilishini to'xtatishi mumkinligi sababli yuzaga keladi.

Bunga qarshi kurashish usullari:

Sinxronizatsiya: Umumiy resurslarga eksklyuziv kirishni ta'minlash uchun sinxronizatsiya primitive'laridan foydalanish.

synchronized kalit so'zi: Metodlar yoki kod bloklariga qo'llaniladi. Joriy oqim tugamaguncha, boshqa oqimlar uchun ob'ekt yoki sinfga kirishni bloklaydi.

// Sinxronlashtirilgan metod
public synchronized void updateData(int newValue) {
    // ... umumiy ma'lumotlarni yangilash
}

// Kod blokini sinxronlashtirish
public void processData() {
    synchronized (this) { // Yoki boshqa monitor ob'ekti
        // ... umumiy ma'lumotlarga kirish
    }
}

Locklar: synchronized bilan solishtirganda, sinxronizatsiya ustidan yanada moslashuvchan nazoratni ta'minlaydi.

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

private final Lock dataLock = new ReentrantLock();

public void safeUpdateData(int newValue) {
    dataLock.lock(); // Lockni olish
    try {
        // ... umumiy ma'lumotlarni yangilash
    } finally {
        dataLock.unlock(); // Lockni bo'shatish
    }
}

Atomik o'zgaruvchilar (Atomic...): Ochiq blokirovsiz, primitiv tiplarda oqimlararo xavfsiz operatsiyalarni ta'minlaydi. Oddiy operatsiyalar uchun ishlatiladi (inkrement, solishtirish va almashtirish).

import java.util.concurrent.atomic.AtomicInteger;

private final AtomicInteger counter = new AtomicInteger(0);

public void incrementCounter() {
    counter.incrementAndGet(); // Atomik oshirish
}

Oqimlararo xavfsiz kolleksiyalar: java.util.concurrent paketidan maxsus kolleksiyalarni ishlatish (masalan, ConcurrentHashMap, CopyOnWriteArrayList) — ular ko'p oqimli kirishga mo'ljallangan.
```
import java.util.concurrent.ConcurrentHashMap;
import java.util.Map;

private final Map<String, Integer> safeMap = new ConcurrentHashMap<>();
```
O'zgarmas (Immutable) obyektlar: Agar ma'lumotlar yaratildiqdan so'ng o'zgarmasa, ularga bir nechta oqimdan xavfsiz murojaat qilish mumkin.

ThreadLocal oqim o'zgaruvchilari: Har bir oqimga o'z nusxasi beriladi, bu esa kirishni raqobatlashishni oldini oladi.

private final ThreadLocal<Integer> threadId = new ThreadLocal<>();

public void setThreadId() {
    threadId.set(Thread.currentThread().getId());
}

public int getThreadId() {
    return threadId.get();
}

To'g'ri arxitektura dizayni: Umumiy o'zgarmaydigan ma'lumotlarni minimallashtirish va oqimlar o'rtasida asinxron yondashuvlar yoki xabarlarni uzatishni qo'llash, yurish shartlarini kamaytirishi mumkin.

Nima uchun iplar poygaslari yuzaga keladi va ularga qarshi kurashish uchun qanday usullar mavjud?