race condition என்றால் என்ன? ஒரு எடுத்துக்காட்டையும் அதன் அறிகுறியையும் கொடுங்கள்.

Question

IT Interview Practice · Accepted Answer

**race condition என்பது ஒரு bug ஆகும், அதில் முடிவு ஆனது shared state-ஐ access செய்யும் concurrent operations-இன் கணிக்க முடியாத timing-ஐச் சார்ந்துள்ளது.** classic வழக்கு atomic அல்லாத ஒரு read-modify-write ஆகும்.

## இது எப்படி வேலை செய்கிறது

`counter += 1` ஆனது atomic-ஆகத் தெரிகிறது ஆனால் உண்மையில் மூன்று படிகள்: read, add, write. இரண்டு threads interleave ஆகலாம், எனவே ஒரு update இழக்கப்படுகிறது.

```text
counter = 0
Thread A: read 0 ─────────── write 1
Thread B:      read 0 ─ write 1
Result: 1  (should be 2 — one increment lost)
```

## எடுத்துக்காட்டு

```python
counter = 0
def inc():
    global counter
    for _ in range(100_000):
        counter += 1          # NOT atomic: read, +1, write

# Run two threads, expect 200_000...
# ...but you often get less — a lost update
```

சரிசெய்தல் என்பது ஒரு lock மூலம் section-ஐ atomic-ஆக ஆக்குவது:

```python
lock = threading.Lock()
def inc():
    global counter
    for _ in range(100_000):
        with lock:            # only one thread in here at a time
            counter += 1
```

## இது ஏன் முக்கியம்

**அறிகுறி** தான் races-ஐ ஆபத்தானதாக்குகிறது: இடைவிட்டு வரும், மீண்டும் உருவாக்க முடியாத தவறான முடிவுகள், அவை tests-இல் தேறி load-இன் கீழ் தோல்வியடைகின்றன. timing மாறும் வரை அவை மறைந்திருக்கின்றன — வேகமான machine, அதிக traffic, ஒரு புதிய core. shared mutable state-ஐ மூல காரணமாக அடையாளம் காண்பது முதல் படி; பாதுகாக்கப்படாத read-modify-write-ஐ நீங்கள் கண்டறிவதை interviewers பார்க்க விரும்புகிறார்கள்.

இது எப்படி வேலை செய்கிறது

எடுத்துக்காட்டு

இது ஏன் முக்கியம்

தொடர்புடைய கேள்விகள்