Почему слабый/сильный танец решает этот сильный справочный цикл? Я не понимаю

Question

Хорошо, я понимаю причину сильного слабого танца.

Один пример: предположим, что B сильно ссылается на блок, и мы устанавливаем этот блок внутри B, чтобы сильно ссылаться на себя (B). Теперь у нас есть B, сильно ссылающийся на наш блок, возможно, наш блок выделен куче для запуска позже (возможно, async), и наш блок сильно ссылается на B. Предположим, что только некоторый объект A сильно ссылается B. Если мы убиваем A, тогда B -> block AND block -> B. Сильный цикл ссылок и утечка памяти.

Другой способ, которым мы могли бы видеть это, - это сильно ссылки B. B сильно ссылки C. Возможно, C имеет свойство блока, а B говорит C.block = ^{ self.blah = blah }. Теперь мы имеем B, строго ссылающийся на C, и C, строго ссылающийся на B. A убит, и мы снова имеем сильный ссылочный цикл. Поправьте меня, если я ошибаюсь в этом.

Теперь я вижу сильный цикл ссылок, который, по моему мнению, не должен быть сильным эталонным циклом.

У меня есть класс, назовем его A. A имеет функцию fooBar. Внутри fooBar, мы звоним

[[MySingleton sharedInstance] doSomeBackgroundJazz: ^{ 
    self.blah = blah; 
}]; 

Мы видим сильный опорный цикл, и A не освобождается. Теперь, на мой взгляд, у A нет сильной ссылки на MySingleton. Может быть, на время fooBar это делает, но сам класс этого не делает. Но когда fooBar сделан, его удаляют из стека, и больше нет ссылки на MySingleton. Исправьте меня, если я ошибаюсь в любой момент. Теперь мы знаем, что наш блок-код, который находится в [MySingleton doSomeBackgroundJazz], сильно ссылается на A. Однако почему это имеет значение? A не ссылается на MySingleton. Мейслингтон сильно ссылается А. Нет необходимости в слабом сильном танце.

Однако, когда я помещал слабый сильный танец в наши проблемы, наши проблемы были смягчены. Больше не держится. (Прямо сейчас проблема реального мира, с которой мы сталкиваемся, оставляет представление и возвращается, продолжает создавать новое представление и сохраняет предыдущие. Каждый из них слушает уведомление и выполняет вызов API. Таким образом, мы можем потенциально иметь десятки API звонки, выходящие каждую секунду).

Почему слабый сильный танец решает это?

Answer 1

Предполагая A ваш вызывающему -doSomeBackgroundJazz:

Он появляется ваш MySingleton класс хранит ваш блок прочь в собственность.

Поскольку вы захватили self (A) в своем блоке, когда блок хранится в свойстве, он также сохраняется.

Так что это означает, что до тех пор, пока ваш экземпляр singleton (sharedInstance) не будет сохранен, его свойство блока сохраняется, и поэтому ваш захваченный A сохраняется.

Не имеет значения, что A не сохраняет sharedInstance, он явно висит вокруг по какой-либо причине.

Правило большого пальца - это лить self с __weak всякий раз, когда блок будет храниться в собственности. Тем не менее, это не повредит, когда вы всегда делаете листинг __weak в любом случае, редко должен быть случай, когда вы хотите, чтобы блок сохранил объект.