ఒక closure అది సూచించే variable లను capture చేస్తుంది, వాటిని సజీవంగా ఉంచుతుంది. ఒక closure self ను capture చేసినప్పుడు మరియు self కూడా closure ను (ఒక stored property) కలిగి ఉన్నప్పుడు, అవి ఒకదానికొకటి శాశ్వతంగా సజీవంగా ఉంచుతాయి — memory ను లీక్ చేసే ఒక . వంటి ఒక ఆ cycle ను విచ్ఛిన్నం చేస్తుంది.
[weak self]ARC ఒక object యొక్క reference count సున్నాకు చేరినప్పుడు దాన్ని విడుదల చేస్తుంది. ఒక strong capture ఆ count ను పెంచుతుంది.
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() {}
}
[weak self] — self optional అవుతుంది; object విడుదలైతే అది nil. Object closure కంటే ఎక్కువ కాలం జీవించే అవకాశం ఉన్నప్పుడు సురక్షితమైన default.[unowned self] — non-optional, ARC overhead లేదు, కానీ self ఇప్పటికే పోయినట్లయితే crash అవుతుంది. self closure కంటే ఎక్కువ కాలం జీవిస్తుందని హామీ ఉన్నప్పుడు మాత్రమే వాడండి.Task { [weak self] in
let data = await self?.fetch() // self? short-circuits if deallocated
}
Non-escaping closure లు (ఉదా. map, filter, forEach) synchronous గా run అవుతాయి మరియు 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 గా reach అవడం కంటే — ARC ను అర్థం చేసుకునే engineer లను దాన్ని cargo-cult చేసేవారి నుండి వేరు చేస్తుంది.
జూనియర్ నుండి సీనియర్ వరకు వివరణాత్మక సమాధానాలతో IT ఇంటర్వ్యూ ప్రశ్నల లైబ్రరీ.
విరాళం