В какой момент происходит изменение в счетчике ссылок?

Изменение счетчика ссылок в ARC

Счетчик ссылок (Reference Count) изменяется в строго определенные моменты, когда изменяется владение объектом в памяти. В iOS/Objective-C/Swift с использованием Automatic Reference Counting (ARC) эти изменения происходят автоматически, но в предсказуемых точках.

Ключевые моменты изменения

1. При создании объекта

При инициализации объекта через alloc/init или new в Objective-C, или при создании экземпляра класса в Swift, счетчик устанавливается в 1.

// Objective-C
MyClass *obj = [[MyClass alloc] init]; // RC = 1

// Swift
let obj = MyClass() // RC = 1

2. При присваивании сильной ссылке

Когда объект присваивается сильной ссылке (strong reference), счетчик увеличивается на 1.

var obj1: MyClass? = MyClass() // RC = 1
var obj2 = obj1 // RC = 2 (новая сильная ссылка)

3. При освобождении сильной ссылки

Когда сильная ссылка выходит из области видимости или ей присваивается nil, счетчик уменьшается на 1.

func example() {
    let obj = MyClass() // RC = 1
    // конец функции: obj уничтожается, RC = 0, память освобождается
}

4. При присваиваниях свойств

При установке свойства объекта, которое является сильной ссылкой:

class Container {
    var content: MyClass?
}

let container = Container()
let obj = MyClass() // RC = 1
container.content = obj // RC = 2
container.content = nil // RC = 1

5. При добавлении в коллекции

Массивы, словари и другие коллекции хранят сильные ссылки на объекты:

var array = [MyClass]()
let obj = MyClass() // RC = 1
array.append(obj) // RC = 2
array.removeLast() // RC = 1

6. При захвате в замыканиях

Замыкания захватывают объекты, увеличивая счетчик ссылок:

class MyClass {
    var value = 0
}

let obj = MyClass() // RC = 1
let closure = { [weak obj] in
    // weak не увеличивает RC
    // unowned тоже не увеличивает, но опасно
    // сильный захват увеличит RC до 2
}

Особенности реализации

Немедленное vs Отложенное изменение

В большинстве случаев ARC изменяет счетчик немедленно, но есть оптимизации:

• Возвращаемое значение функций может использовать autorelease в Objective-C
• Swift использует более агрессивные оптимизации, включая пропуск некоторых изменений счетчика

Атомарность операций

Изменение счетчика ссылок — атомарная операция, что гарантирует потокобезопасность:

// Псевдокод атомарной операции
int32_t __sync_add_and_fetch(int32_t *ptr, int32_t value);

Оптимизации компилятора

Компилятор может оптимизировать изменения счетчика:

• Локальные переменные могут не увеличивать счетчик, если объект не покидает область видимости
• Inlining может устранять промежуточные изменения

Пример полного жизненного цикла

class Example {
    init() { print("Создан") }
    deinit { print("Уничтожен") }
}

func test() {
    var ref1: Example? = Example() // RC = 1, "Создан"
    var ref2: Example? = ref1      // RC = 2
    
    if true {
        var ref3 = ref1            // RC = 3
    }                              // RC = 2 (ref3 уничтожен)
    
    ref1 = nil                     // RC = 1
    ref2 = nil                     // RC = 0, "Уничтожен", память освобождена
}

Важные нюансы

1. Слабые (weak) и бесхозные (unowned) ссылки не увеличивают счетчик
2. Циклические ссылки возникают, когда объекты ссылаются друг на друга, создавая "вечный" счетчик > 0
3. Autorelease pools в Objective-C откладывают уменьшение счетчика
4. Сборка мусора в других языках работает иначе, но в iOS/макOS используется исключительно ARC

Итог: Счетчик ссылок изменяется при каждом изменении сильных ссылок на объект — создании, присваивании, освобождении. ARC автоматически вставляет соответствующие вызовы retain/release во время компиляции, обеспечивая предсказуемое управление памятью без накладных расходов сборщика мусора.