Swift Academy · Lekcja

Cykle retain: przyczyny i wykrywanie

Wykrywanie cykli retain między obiektami i domknięciami za pomocą Instruments.

Cykle retain: przyczyny i wykrywanie to bezpłatna lekcja Swift Academy na CoddyKit. To lekcja 2 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Swift Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Swift Academy zawiera 4 lekcji w sumie.

Wprowadzenie

Cykl referencji występuje, gdy co najmniej dwa obiekty przechowują wzajemnie silne referencje, uniemożliwiając ARC osiągnięcie przez licznik wartości zero — prowadzi to do wycieku pamięci.

Prosty cykl dwóch obiektów

```swift class Owner { var pet: Pet? } class Pet { var owner: Owner? } var o: Owner? = Owner() var p: Pet? = Pet() o?.pet = p // Owner → Pet (strong) p?.owner = o // Pet → Owner (strong) o = nil; p = nil // Neither deinit called — cycle! ```

Cykl rodzic–element potomny

```swift class Node { var children: [Node] = [] var parent: Node? // strong → cycle with parent } let root = Node() let child = Node() root.children.append(child) child.parent = root // cycle ```

Cykl przechwytywania przez domknięcie

```swift class ViewController { var onComplete: (() -> Void)? func setup() { onComplete = { // closure strongly captures self self.doWork() // ← cycle! } } } ```

Cykl we wzorcu delegata

```swift protocol TaskDelegate: AnyObject { func didFinish() } class Task { var delegate: TaskDelegate? // if strong → potential cycle } class Manager: TaskDelegate { var task = Task() init() { task.delegate = self } // Manager → Task → Manager } ```

Wykrywanie za pomocą Instruments

Użyj Xcode Instruments → Leaks: 1. Uruchom aplikację w Instruments 2. Kliknij instrument Leaks 3. Czerwone oznaczenia wskazują obiekty, z których wystąpił wyciek 4. Przejdź do szczegółów, aby zobaczyć graf referencji Alternatywnie ustaw `deinit { print(...) }` i sprawdź, czy zostanie wywołane.

Wykrywanie za pomocą Memory Graph w Xcode

W debugerze Xcode wybierz Debug > Memory Graph Debugger. Kliknij obiekt, z którego wystąpił wyciek, aby zobaczyć łańcuch jego referencji — cykl będzie widoczny na grafie jako zamknięta pętla.

Typowe wzorce cykli

• Delegat przechowujący delegata za pomocą silnej referencji • Domknięcie silnie przechwytujące `self` • Dwukierunkowe silne referencje między rodzicem a elementem potomnym • Obserwator NotificationCenter przechowujący domknięcie, które przechwytuje self • Cel obiektu Timer będący `self` (silna referencja)

Cykl referencji obiektu Timer

```swift class Poller { var timer: Timer? func start() { timer = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { [weak self] _ in self?.poll() // weak self breaks cycle } } deinit { timer?.invalidate() } } ```

Cykl NotificationCenter

```swift class Listener { var token: NSObjectProtocol? init() { token = NotificationCenter.default.addObserver(forName: .UIApplicationDidBecomeActive, object: nil, queue: .main) { [weak self] _ in self?.refresh() } } deinit { NotificationCenter.default.removeObserver(token!) } } ```

Szybkie sprawdzenie

Czym jest cykl retencji w ARC?

Podsumowanie

Najważniejsze informacje: • Cykle retencji: wzajemne silne referencje → żaden obiekt nie zostaje dealokowany • Często występują w: delegatach, domknięciach oraz dwukierunkowych relacjach rodzic-dziecko • Można je wykrywać za pomocą Instruments Leaks lub Xcode Memory Graph Debugger • Należy je naprawiać za pomocą referencji `weak` lub `unowned` • Timery i NotificationCenter również mogą powodować cykle — należy je przerywać za pomocą `[weak self]` Następny temat: referencje weak i unowned.

Często zadawane pytania

Czy lekcja „Cykle retain: przyczyny i wykrywanie” jest bezpłatna?

Tak — pełny tekst „Cykle retain: przyczyny i wykrywanie” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Swift Academy, przejdź na CoddyKit PRO. Kurs Swift Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Cykle retain: przyczyny i wykrywanie”?

Wykrywanie cykli retain między obiektami i domknięciami za pomocą Instruments. Ćwiczysz Swift Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Swift Academy?

Nie wymagamy żadnego doświadczenia. Swift Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 2 z 4.

Ile czasu zajmuje lekcja „Cykle retain: przyczyny i wykrywanie”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Swift Academy?

Tak. Każda lekcja Swift Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

Jak ARC zlicza odwołania
Cykle retain: przyczyny i wykrywanie
Odwołania weak i unowned
Listy przechwytywania domknięć i [weak self]

← Powrót do Swift Academy