capture list-கள் என்றால் என்ன, closure-களில் retain cycle-களை எப்படித் தவிர்ப்பது?

Question

IT Interview Practice · Accepted Answer

ஒரு closure தான் குறிப்பிடும் variable-களை **capture** செய்து அவற்றை உயிருடன் வைத்திருக்கிறது. ஒரு closure `self`-ஐ capture செய்யும்போது மற்றும் `self`-உம் closure-ஐ வைத்திருக்கும்போது (ஒரு stored property), அவை ஒன்றையொன்று என்றென்றும் உயிருடன் வைத்திருக்கின்றன — memory-ஐ கசியவைக்கும் ஒரு **retain cycle**. `[weak self]` போன்ற ஒரு **capture list** அந்த cycle-ஐ உடைக்கிறது.

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

ஒரு object-இன் reference count பூஜ்ஜியத்தை அடையும்போது ARC அதை விடுவிக்கிறது. ஒரு strong capture அந்த count-ஐ அதிகரிக்கிறது.

```swift
final class Downloader {
    var onDone: (() -> Void)?          // stored closure -> strong

func start() {
        // BAD: closure captures self strongly, self holds closure -> cycle
        onDone = { self.cleanup() }

// GOOD: weak capture, self can deallocate
        onDone = { [weak self] in
            guard let self else { return }   // safely unwrap; bail if gone
            self.cleanup()
        }
    }
    func cleanup() {}
}
```

## capture list-களில் weak vs unowned

- **`[weak self]`** — `self` ஒரு optional ஆகிறது; object விடுவிக்கப்பட்டால் அது `nil`. object closure-ஐ விட நீண்ட காலம் வாழக்கூடும் போது பாதுகாப்பான default.
- **`[unowned self]`** — non-optional, ARC overhead இல்லை, ஆனால் `self` ஏற்கனவே போய்விட்டால் **crash** ஆகும். `self` closure-ஐ விட நீண்ட காலம் வாழும் என உறுதிசெய்யப்படும்போது மட்டுமே பயன்படுத்துங்கள்.

```swift
Task { [weak self] in
    let data = await self?.fetch()       // self? short-circuits if deallocated
}
```

## capture list தேவைப்படாத போது

Non-escaping closure-கள் (எ.கா. `map`, `filter`, `forEach`) synchronous-ஆக இயங்கி capture-களை உடனடியாக விடுவிக்கின்றன — cycle இல்லை, `[weak self]` தேவையில்லை. அபாயம் **escaping, stored** closure-களுடன்: completion handler-கள், `Timer`, `NotificationCenter`, Combine sink-கள், delegate block-கள்.

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

Retain cycle-கள் iOS-இல் மிகவும் பொதுவான memory leak, மேலும் Instruments வளரும் memory-ஐக் காட்டும் வரை அவை கண்ணுக்குத் தெரியாதவை. ஒரு closure *எப்போது* escape செய்கிறது மற்றும் `[weak self]` *ஏன்* தேவை என்பதைத் துல்லியமாக அறிவது — அதை எல்லா இடங்களிலும் reflexive-ஆக நாடுவதற்குப் பதிலாக — ARC-ஐ புரிந்துகொள்ளும் engineer-களை அதை cargo-cult செய்பவர்களிடமிருந்து பிரிக்கிறது.

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

capture list-களில் weak vs unowned

capture list தேவைப்படாத போது

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

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