iOS Memory Management: ARC ve Memory Leaks

1// Strong reference (varsayılan)
2class Person {
3    let name: String
4    var apartment: Apartment?
5    
6    init(name: String) {
7        self.name = name
8        print("\(name) initialized")
9    }
10    
11    deinit {
12        print("\(name) deinitialized")
13    }
14}
15 
16class Apartment {
17    let unit: String
18    var tenant: Person?  // Strong reference
19    
20    init(unit: String) {
21        self.unit = unit
22    }
23    
24    deinit {
25        print("Apartment \(unit) deinitialized")
26    }
27}
28 
29// ❌ RETAIN CYCLE
30var john: Person? = Person(name: "John")
31var unit4A: Apartment? = Apartment(unit: "4A")
32 
33john?.apartment = unit4A
34unit4A?.tenant = john
35 
36john = nil  // Person not deallocated!
37unit4A = nil  // Apartment not deallocated!
38// Memory leak!

1// WEAK - Nesne nil olabilir
2class Apartment {
3    let unit: String
4    weak var tenant: Person?  // Weak reference
5    
6    init(unit: String) {
7        self.unit = unit
8    }
9}
10 
11// UNOWNED - Nesne her zaman var olacak
12class Customer {
13    let name: String
14    var card: CreditCard?
15    
16    init(name: String) {
17        self.name = name
18    }
19}
20 
21class CreditCard {
22    let number: String
23    unowned let customer: Customer  // Unowned - customer her zaman var
24    
25    init(number: String, customer: Customer) {
26        self.number = number
27        self.customer = customer
28    }
29}
30 
31// Kullanım
32let customer = Customer(name: "John")
33customer.card = CreditCard(number: "1234", customer: customer)
34// Retain cycle yok!

1class NetworkManager {
2    var onComplete: (() -> Void)?
3    
4    func fetchData() {
5        // API call...
6    }
7}
8 
9class ViewController: UIViewController {
10    let networkManager = NetworkManager()
11    var data: [String] = []
12    
13    func loadData() {
14        // ❌ RETAIN CYCLE
15        networkManager.onComplete = {
16            self.data = ["item1", "item2"]  // Strong capture
17            self.tableView.reloadData()
18        }
19        
20        // ✅ WEAK CAPTURE
21        networkManager.onComplete = { [weak self] in
22            guard let self = self else { return }
23            self.data = ["item1", "item2"]
24            self.tableView.reloadData()
25        }
26        
27        // ✅ UNOWNED CAPTURE (ViewController her zaman var olacaksa)
28        networkManager.onComplete = { [unowned self] in
29            self.data = ["item1", "item2"]
30            self.tableView.reloadData()
31        }
32    }
33}
34 
35// Multiple captures
36someAsyncFunction { [weak self, weak delegate, networkManager] in
37    guard let self = self else { return }
38    // networkManager is captured strongly (value type)
39    // self and delegate are weak
40}

1// 1. Timer retain cycle
2class TimerViewController: UIViewController {
3    var timer: Timer?
4    
5    override func viewDidLoad() {
6        super.viewDidLoad()
7        
8        // ❌ RETAIN CYCLE
9        timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { _ in
10            self.updateUI()
11        }
12        
13        // ✅ WEAK CAPTURE
14        timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
15            self?.updateUI()
16        }
17    }
18    
19    override func viewWillDisappear(_ animated: Bool) {
20        super.viewWillDisappear(animated)
21        timer?.invalidate()
22    }
23}
24 
25// 2. NotificationCenter
26class NotificationViewController: UIViewController {
27    var observer: NSObjectProtocol?
28    
29    override func viewDidLoad() {
30        super.viewDidLoad()
31        
32        observer = NotificationCenter.default.addObserver(
33            forName: .someNotification,
34            object: nil,
35            queue: .main
36        ) { [weak self] notification in
37            self?.handleNotification(notification)
38        }
39    }
40    
41    deinit {
42        if let observer = observer {
43            NotificationCenter.default.removeObserver(observer)
44        }
45    }
46}
47 
48// 3. Delegate pattern
49protocol DataManagerDelegate: AnyObject {
50    func dataDidUpdate(_ data: [String])
51}
52 
53class DataManager {
54    weak var delegate: DataManagerDelegate?  // Always weak!
55}

1// ❌ Bellek spike - tüm image'lar loop bitene kadar bellekte
2func processImages(paths: [String]) {
3    for path in paths {
4        let image = UIImage(contentsOfFile: path)
5        let processed = applyFilter(to: image)
6        saveToGallery(processed)
7    }
8}
9 
10// ✅ Autorelease pool ile her iterasyonda temizle
11func processImages(paths: [String]) {
12    for path in paths {
13        autoreleasepool {
14            let image = UIImage(contentsOfFile: path)
15            let processed = applyFilter(to: image)
16            saveToGallery(processed)
17        } // Her iterasyonda geçici nesneler serbest bırakılır
18    }
19}

1// Struct kullanarak retain cycle'dan tamamen kaçınma
2struct UserProfile {
3    let name: String
4    let email: String
5    var settings: AppSettings // Nested struct, reference cycle imkansız
6}
7 
8// Class gerektiğinde - identity semantics veya inheritance için
9class UserSession {
10    let profile: UserProfile  // Struct property - leak riski yok
11    weak var delegate: SessionDelegate?  // Weak delegate
12 
13    init(profile: UserProfile) {
14        self.profile = profile
15    }
16}

1#if DEBUG
2func debugRetainCount(_ object: AnyObject) {
3    print("Retain count: \(CFGetRetainCount(object))")
4}
5 
6// Allocation tracking ile leak detection
7final class AllocationTracker {
8    static let shared = AllocationTracker()
9    private var allocations: [String: Int] = [:]
10    private let queue = DispatchQueue(label: "allocation.tracker")
11 
12    func track(_ type: String) {
13        queue.sync {
14            allocations[type, default: 0] += 1
15            print("📈 \(type) allocated. Total: \(allocations[type]!)")
16        }
17    }
18 
19    func release(_ type: String) {
20        queue.sync {
21            allocations[type, default: 0] -= 1
22            print("📉 \(type) released. Total: \(allocations[type]!)")
23        }
24    }
25 
26    func reportLeaks() {
27        queue.sync {
28            let leaks = allocations.filter { $0.value > 0 }
29            if leaks.isEmpty {
30                print("✅ No memory leaks detected!")
31            } else {
32                print("⚠️ Potential leaks:")
33                leaks.forEach { print("  - \($0.key): \($0.value) instances") }
34            }
35        }
36    }
37}
38#endif

1// ❌ ObservableObject ile retain cycle riski
2class ParentViewModel: ObservableObject {
3    @Published var child: ChildViewModel?
4 
5    init() {
6        child = ChildViewModel(parent: self) // Retain cycle!
7    }
8}
9 
10class ChildViewModel: ObservableObject {
11    let parent: ParentViewModel // Strong reference to parent
12    init(parent: ParentViewModel) {
13        self.parent = parent
14    }
15}
16 
17// ✅ Weak reference ile düzelt
18class ChildViewModel: ObservableObject {
19    weak var parent: ParentViewModel?
20    init(parent: ParentViewModel) {
21        self.parent = parent
22    }
23}
24 
25// ✅ iOS 17+ @Observable ile daha temiz
26@Observable
27class ParentModel {
28    var items: [String] = []
29    // @Observable struct reference cycle riski azaltır
30    // çünkü observation tracking otomatik yönetilir
31}

1// UIKit
2override func didReceiveMemoryWarning() {
3    super.didReceiveMemoryWarning()
4    imageCache.removeAllObjects()
5    dataCache.removeAll()
6}
7 
8// SwiftUI + Combine
9NotificationCenter.default
10    .publisher(for: UIApplication.didReceiveMemoryWarningNotification)
11    .sink { [weak self] _ in
12        self?.clearCaches()
13    }
14    .store(in: &cancellables)