5. WHY DO WE NEED MEMORY
MANAGEMENT?
func createPerson() {
var p = Person()
}
main
createPerson()
Person
Stack Heap
6. WHY DO WE NEED MEMORY MANAGEMENT?
class Business {
var owner: Person
init() {
self.owner = Person()
}
}
1
1
2
…
…
Person
Stack Heap
Business
ViewController
Reference Count
9. MANUAL REFERENCE COUNTING
Retain count of an object is mainly determined by calls to three
different methods: retain, release, autorelease
Additionally objects you create have a retain count of 1 - in Obj-
C this is indicated by calling any method named “alloc”, “new”,
“copy”, or “mutableCopy”
13. AUTOMATIC REFERENCE
COUNTING (ARC)
No manual calls to retain, release, autorelease
anymore
Memory Management calls are inserted at compile time
Think in strong, weak and unowned references
16. ARC VS. TRACING GARBAGE
COLLECTORS
Tracing Garage Collectors are used in many higher level languages
such as C#, Java and Ruby (Python uses reference counts)
17. ARC VS. TRACING GARBAGE
COLLECTORS
Tracing GCs collect unreferenced objects after certain time periods at
runtime, typically work in two phases:
1. Mark all objects that are reachable from a root object
2. Delete all objects that are not reachable from a root object
19. GOTCHAS
Pure reference counting garbage collection mechanisms
cannot detect retain cycles!
Retain cycles occur when multiple objects reference each
other strongly, but aren’t strongly referenced by any root
object
20. GOTCHAS
Retain cycles created by the usage of closures:
class UserViewController: UIViewController {
var callback: UserDetailsCallback?
override func viewDidAppear(animated: Bool) {
callback = { user in
self.showUser(user)
}
}
func showUser(user: User?) {
//...
}
}
UserViewController
UserDetailsCallback+1
+1
21. GOTCHAS
Fix retain cycles using weak/unowned:
class UserViewController: UIViewController {
var callback: UserDetailsCallback?
override func viewDidAppear(animated: Bool) {
callback = { [unowned self] user in
self.showUser(user)
}
}
func showUser(user: User?) {
//...
}
}
UserViewController
UserDetailsCallback+1
+0
22. GOTCHAS
Retain cycles created by the usage of strong delegates:
protocol UserViewDelegate {}
class UserView {
var delegate: UserViewDelegate?
}
class UserViewController: UIViewController {
var userView: UserView = UserView()
func viewDidLoad() {
super.viewDidLoad()
userView.delegate = self
}
}
UserViewController
UserView+1
+1
23. GOTCHAS
Fix using a weak reference to the delegate:
protocol UserViewDelegate {}
class UserView {
weak var delegate: UserViewDelegate?
}
class UserViewController: UIViewController {
var userView: UserView = UserView()
func viewDidLoad() {
super.viewDidLoad()
userView.delegate = self
}
}
UserViewController
UserView+1
+0
25. SUMMARY
Swift’s memory management model is based on reference
counting
With ARC reference counting works semi-automatically, retain
and release calls are inferred from memory management
specifiers (strong, weak, unowned)
Some types of memory issues that can be detected by tracing
GCs cannot be detected by reference counting, e.g. retain
cycles