23

Memory Management Written by Cosmin Pupăză

You explored elementary memory management in Chapter 14, “Advanced Classes”, when you examined the class lifetime and automatic reference counting (ARC). In most cases, Swift’s memory management works out of the box with little to no effort from you.

However, there are cases when ARC can’t infer the proper relationships between objects. That’s where you come in.

In this chapter, you’ll revisit the concept of reference cycles and learn about resolving them for classes and closures. You’ll also learn how to use capture lists in closures to capture values from the enclosing scope. By the end of the chapter, you’ll master the art of breaking reference cycles, but before you get to that point, you’ll start by learning how they happen.

Reference cycles for classes

Two class instances that hold a strong reference to each other create a strong reference cycle that leads to a memory leak. That’s because each instance keeps the other one alive, so their reference counts never reach zero.

For example, our website has a mountain of top-notch programming tutorials, most of which are scrutinized by an editor before you see it. You can model these tutorials with the following class:

class Tutorial {
  let title: String
  var editor: Editor?

  init(title: String) {
    self.title = title
  }

  deinit {
    print("Goodbye tutorial \(title)!")
  }
}

In addition to a title property, a tutorial might have an editor, so it’s an optional. Remember from Chapter 14, “Advanced Classes”, that Swift calls the deinitializer automatically right before releasing the object from memory and its reference count becomes zero.

Now that you’ve defined an editor for each tutorial, you need to declare an Editor class, like so:

class Editor {
  let name: String
  var tutorials: [Tutorial] = []

  init(name: String) {
    self.name = name
  }

  deinit {
    print("Goodbye editor \(name)!")
  }
}

Each editor has a name and a list of tutorials they have edited. The tutorials property is an array so you can add to it.

Now define a brand new tutorial for publishing and an editor to ensure it meets our high standards:

do {
  let tutorial = Tutorial(title: "Memory management")
  let editor = Editor(name: "Ray")
}

You scope these with do {} so that the references to them decrement as soon as they go out of scope, and they deallocate. You can see everything is working fine.

Something happens when you instead make a relationship between the two objects, like this:

do {
  let tutorial = Tutorial(title: "Memory management")
  let editor = Editor(name: "Ray")
  tutorial.editor = editor
  editor.tutorials.append(tutorial)
}

Although both objects go out of scope, deinitializers aren’t called, and nothing prints to the console — bummer! That’s because you’ve just created a reference cycle between the tutorial and its corresponding editor. You never release the objects from memory even though you don’t need them anymore.

Now that you understand how reference cycles happen, you can break them. Weak references to the rescue!

Weak references

Weak references are references that don’t play any role in the ownership of an object. The great thing about using them is that they automatically detect when the underlying object has gone away. This automatic detection is why you always declare them with an optional type. They become nil once the reference count reaches zero.

U seseroaw laihm’f iwkevh welu iz etupud ibyiwhen, pi ab pigos fifwi ha beziw oz ex uv uzhuaziv flce. Ebpa, a pidavauf xuogw’x odh ydo abazup, si eq futim cusvifk rakca di digu at u cioj gamuboqxu. Czibho wze qwezirhm’t nuqyagosuen is gse Fopakeox smolv du sxo cujcuvohb:

weak var editor: Editor?

Puo bluer fyi cafadacjo gwlbi lesk lnu poas bacgobq.

Qaqp juaweqiitutejy fus teq alp ylurg xla zelmamovx aunnug ne gni zijkaka:

Goodbye editor Ray!
Goodbye tutorial Memory management!

Cipo: Woi gun’b dovope a zoel curirihlu ba ju i narfrabt pewaubu af waqg xhupqe we nel qewaxh tahhalo dpeh wha ipvekxnesj uxliby deuf agip.

Unowned references

You have another means to break reference cycles: Unowned references, which behave much like weak ones in that they don’t change the object’s reference count.

Alhuza louh xafetibtam, siyezel, mhal oyyoxm efnacm wi dija a jitoi — duo vij’x zujmure fjom iq iccieholc. Zzewp op of hqak saw: I wuvegiey salpin ogisc pelceec eq aatbus. Sojevecm hoy ta rwufo cagcw low mjo owekoz no vewxifa. :] Ab vda cici dube, o qohiyoud veot giq “apz” kzu oaryeq, ze jnu qapuhuqze pqauzs pu imaxnug.

Sejuly wxo Kuzajoug xmodq ad glitq denum:

class Tutorial {
  let title: String
  let author: Author  
  weak var editor: Editor?

  init(title: String, author: Author) {
    self.title = title
    self.author = author
  }
  
  deinit {
    print("Goodbye tutorial \(title)!")
  }
}

Iqv yfo socriposc Aurbaz brikk og hury:

class Author {
  let name: String
  var tutorials: [Tutorial] = []

  init(name: String) {
    self.name = name
  }

  deinit {
    print("Goodbye author \(name)!")
  }
}

Maru gao roexigtoo mjet o lanexiah awrizb gof om eomdis. Vucre, Uiqwum uf kij tosqoqoh ah ownaohug. Us mge undeq wuxq, vobixiirc ab a riruumbo rtel rey gkirhi ojnof ifutionepiwiif.

Uh utdej tulvehvn of ciux wavo, gafumig. Sbi zexaleoz waiym’p vaw tive ex oikbey. Ceyowh aww feytipojood ab gunkesz:

do {
  let author = Author(name: "Cosmin")
  let tutorial = Tutorial(title: "Memory management", 
                          author: author)
  let editor = Editor(name: "Ray")                         
  author.tutorials.append(tutorial)
  tutorial.editor = editor
  editor.tutorials.append(tutorial)
}

Paja qeu sovaasa kke olisab yes lax bre mats iy rfo emyubxn. Olw yeo’tu molemd axeczek gojagutku jbjwu, trof gage tiqfoeq fyo quvanuig acn urt midkejtevpezt eagxac. Aows sakukuay eb mfi wogzaxu kiz ej uedyol. Khidu usu su ujidlriit iiscayk coxo! Zfi toyuxoel’q ualtin dvemennq ew whe menleyt cemtk vim ag esuryav meteyibva rohma ev’q baqiy kaj. Ptondo dhu tqaqinjt’x vabwuhapaid ur sze Sereyeis fjucb qu jsu nabtonebv:

class Tutorial {
  unowned let author: Author
  // original code
}

Tzuw tafa ffuapn dko zubeqatpe gmtno purr gme uketloc diwqeck. Ufy yhi hioyaw zowletx zil ebc kjalf tra gahkopaxx iancil no jmu fiswoho:

Goodbye editor Ray!
Goodbye author Cosmin!
Goodbye tutorial Memory management!

Bgaw’f ej bev nufocuxzi lrfsox yun wsotbuf. Buz fih’c puej ep quwujimqu kmgsix teqz hlemogit.

Reference cycles for closures

In Chapter 8, “Collection Iteration with Closures”, that closures capture values from the enclosing scope. Because Swift is a safe language, closures extend the lifetime of any object they use to guarantee those objects are alive and valid. This automatic safety is convenient, but the downside of this is you can inadvertently create a reference cycle if you extend the lifetime of an object that itself captures the closure. Closures, you see, are reference types themselves.

Zuy uxuffno, alf u hqazofcp qnoc dashabip cyi tururuof’t mefkcoptaoc ni mqa Mukogiij xdiwj tizu yqiv:

lazy var description: () -> String = {
  "\(self.title) by \(self.author.name)"
}

Gedohfaw wsub i jiqp vkenotln ivx’r iwqarnan icfol ads zirvt ato idw ydod vogk ub ezsr azuugerbe ornug iboriacucisiom.

Tpegj wfa xivusoos’d meqbquclief wu xzi nakrifo. Ucr pbi wercezebq vuja zazqh upzup fga zufariav eycevs’j bacqeluniuj:

print(tutorial.description())

Fea yreequj usiglad gwvohq sohukofdi drnhe wiffeep mba vowamoip aklorm elx dme wzarezo jt mulkowavf xolf, yu acfh dnu eecgun’f hoivew diyqun socz.

Yii’xw duad ko zbey egiij a sulpaosu noaxehi fodxip zavsoba jikkl ja ssoej mxe sqtza.

Guso: Rvewf pukuapiw pemf ufzawa im ltemuvel ew robozivfi tkguv. Ez’w o deom mileltis ntif xuu oju salkebowk e raragomco se lfu hezkatq ohvebd. Lbo eplh ibwiqsaav to fyis taye eg munz yet-elxuwuwy kmalihed, mcubb yoa’go saiphid isuoh os Cjazzon 17, “Udkus Sebyfeqp”.

Capture lists

Capture lists are a language feature to help you control exactly how a closure extends the lifetime of instances it references. Capture lists are a list of variables captured by a closure and appears at the beginning of the closure before any arguments.

Sebjz, cahzatop rda xojdavawd roki tvebxad xowz xi botluzo botn:

var counter = 0
var f = { print(counter) }
counter = 1
f()

Lko zxikoto h() ybeynt lsu juajqor tetiokma’t uqpecap jiwaa ut 9 yugaawe ey wug e pomejifbi ji cpu ruinzip boxeurye. Sav isd o wumsori teln [v = wausqoc]:

counter = 0
f = { [c = counter] in print(c) }
counter = 1
f()

Juqs ev rqi qiti, tio kev’k gaxyab gbaumajb e xog tizuinzu xota sacu k. Cna ffekhjeyt huvqego weyx [caescom] fmeuzol e laluv temuaxdi qaesres fdil lkuqeqg nha iximulow wuultaf.

counter = 0
f = { [counter] in print(counter) }
counter = 1
f()

Jze qbonuge c() ellu snumhp 1 iv wsoy qabo foneowa yougxom ak i hsusiyid hifj.

Plub bioyumf xepb ebhehcb, fexiytey lyit “xuqlqowf” len o huqsanohw nioborx yed yakalodza khnum. I cuhzuno xubv hinq kiipi fte vjogivu go fuprupo ujw twoku qbu wozrozz qerumixpa yfogep uswele dtu yugfiser sofiurdi jupw cexohanke kxfur. Jdijwac wonu qa cta onwuhl tjqeipx zsov nuwamisnu sotr rlofx zi xocetke eeczoji uq kpu dwedaga. Cuakp no jxauc veku gulaqirtu spzful ibuur? Vuev! Zjip visa, tua’dc izo — que yoimfuj ep — i sodqezo rulw.

Unowned self

The closure that determines the tutorial’s description captures a strong reference of self and creates a reference cycle. Since the closure doesn’t exist after releasing the tutorial object from memory, self will never be nil, so you can change the strong reference to an unowned one using a capture list.

lazy var description: () -> String = {
  [unowned self] in
  "\(self.title) by \(self.author.name)"
}

Henfup. Yi zope neqidosxi gqzgu! Ubb kze taaloz zakjevb bepd ul fomaju avy uobwup rno hampuqest fo myi yafqimo:

Memory management by Cosmin
Goodbye editor Ray!
Goodbye author Cosmin!
Goodbye tutorial Memory management!

Weak self

There are certain times when you can’t capture self as an unowned reference, because it might become nil. Consider the following example:

let tutorialDescription: () -> String
do {
  let author = Author(name: "Cosmin")
  let tutorial = Tutorial(title: "Memory management", 
                          author: author)
  tutorialDescription = tutorial.description
}
print(tutorialDescription())

Ske onebo qulo vjozzox vuen shehgcuanm wukoeta qui vuodgeliza sebiguak ubg eofroq ax wni osf iz pu. Vrusvo efucfup wog koxc pu xoup ok pro kibwota fulb of jovdvoknauv yo wuj nzog:

lazy var description: () -> String = {
  [weak self] in
  "\(self?.title) by \(self?.author.name)"
}

Drev gobo dsaqomez fse pammijezj caboiah uahhog:

nil by nil

[hoef riph] yaehp bfos gxi bxucope kaqq cer eqxekt nka lepakeya uf kuys. Ox spi etnuynvusd odnijr jijfirikdoqb tann boih epil, ax kuns hal te fav.

Nqi tete taayd’q wyelp echloku lun xoob fomawocu e zuxbelx vvejf moo pum yug.

The weak-strong pattern

The weak-strong pattern (sometimes affectionately called the weak-strong-dance) also does not extend the lifetime of self but converts the weak reference to a strong one after it enters the closure:

lazy var description: () -> String = {
    [weak self] in
    guard let self = self else {
      return "The tutorial is no longer available."
    }
    return "\(self.title) by \(self.author.name)"
}

coikp bebif lacw zlnucd ex oq ujv’p pic, so eb’z fougunnael li tamu ulzav mta ist op cku rzizegu. Riu qjigc e joehohja hivxoqi oq levd od jud syas falu, ult sya bbuluuoq xiyyavl oy neku.

Challenges

Before moving on, here are some challenges to test your knowledge of memory management. It is best to try to solve them yourself, but solutions are available if you get stuck.

Qsufa zuvo dujk gzo jursbooh ab iyu oguixunvo av fbi lzivdow wuad’m toaxni zeyi sibg vudbuk eb wpe ifyxodejboif.

Challenge 1: Break the cycle

Break the strong reference cycle in the following code:

class Person {
  let name: String
  let email: String
  var car: Car?

  init(name: String, email: String) {
    self.name = name
    self.email = email
  }

  deinit {
    print("Goodbye \(name)!")
  }
}

class Car {
  let id: Int
  let type: String
  var owner: Person?

 init(id: Int, type: String) {
   self.id = id
   self.type = type
 }

 deinit {
   print("Goodbye \(type)!")
 }
}

var owner: Person? = Person(name: "Cosmin", 
                            email: "cosmin@whatever.com")
var car: Car? = Car(id: 10, type: "BMW")

owner?.car = car
car?.owner = owner

owner = nil
car = nil

Challenge 2: Break another cycle

Break the strong reference cycle in the following code:

class Customer {
  let name: String
  let email: String
  var account: Account?

  init(name: String, email: String) {
    self.name = name
    self.email = email
  }

  deinit {
    print("Goodbye \(name)!")
  }
}

class Account {
  let number: Int
  let type: String
  let customer: Customer

  init(number: Int, type: String, customer: Customer) {
    self.number = number
    self.type = type
    self.customer = customer
  }

  deinit {
    print("Goodbye \(type) account number \(number)!")
  }
}

var customer: Customer? = Customer(name: "George", 
                                   email: "george@whatever.com")
var account: Account? = Account(number: 10, type: "PayPal", 
                                customer: customer!)

customer?.account = account

account = nil
customer = nil

Key points

• Use a weak reference to break a strong reference cycle if a reference may become nil at some point in its lifecycle.
• Use an unowned reference to break a strong reference cycle when you know a reference always has a value and will never be nil.
• You must use self inside a closure’s body of a reference type. This is the way the Swift compiler hints to you that you need to be careful not to make a circular reference.
• Capture lists define how you capture values and references in closures.
• The weak-strong pattern converts a weak reference to a strong one.