Chapter 23: Async Closures and Memory Management

大綱

• Playgrounds and reference cycles

• Reference cycles for classes

  • Weak references

  • Unowned references

• Reference cycles for closures

  • Capture lists

  • Unowned self

• Handling escaping closures

  • GCD

  • Weak self

  • The strong-weak pattern

• Key points

Playgrounds and reference cycles

“Playgrounds sometimes add extra "invisible" references to objects as you run them. Because of this, objects do not deallocate when then normally should. This makes it difficult to study reference counting using Playgrounds. Because of this, for this chapter you can use a Swift macOS command line tool to test out reference cycles.”

Reference cycles for classes

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

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

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

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

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

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

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

do {
  let tutorial = Tutorial(title: "Memory management", author: author)
  let editor = Editor(name: "Ray")
  // 產生Reference cycles
  tutorial.editor = editor
  editor.tutorials.append(tutorial)
}

Weak references

• Weak references不會增加某個object的reference count。

• Weak只能用在宣告成optional的那些屬性上。

• 在上面的例子中，不是每個tutorial都一定有editor, 因此把它宣告成weak。

 weak var editor: Editor?

Unowned references

• 跟Weak一樣，不會增加reference count, 但只能用在那些不是optional的屬性上。

• 例如，每個tutorial都一定會有個author。

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

  init(title: String, author: Author) {
    self.title = title
    self.author = author
  }

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

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

  init(name: String) {
    self.name = name
  }
  deinit {
    print("Goodbye Author \(name)!")
  }
}

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

Reference cycles for closures

• Clousure也是屬於一個reference type，所以也有可能跟其他type產生reference cycle。

• 在Tutorial class中加入一個lazy property

  • lazy property不會被assign任何值，直到第一次使用。

lazy var createDescription: () -> String = {
  // 產生一個strong reference cycle
 // tutorial object 和 closure by capturing self
  return "\(self.title) by \(self.author.name)"
}
print(tutorial.createDescription())

Capture lists

• A capture list is a list of variables captured by a closure.

• A capture list appears at the very beginning of the closure before any arguments.

• With reference types, a capture list will cause the closure to capture and store the current reference stored inside the captured variable.

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

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

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

Unowned self

• 在closure的capture list加上unowned 解除closure跟物件tutorial之間的reference cycle。

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

Handling escaping closures

• non-escaping: Array中的flitter closure

  • After the filter completes, the closure is never accessed again and is said to be non-escaping

• escaping closures: GCD closure

  • The danger is that since the order of completion changes from run to run, you must be careful not to access an unowned reference that may have disappeared

GCD

// 打印目前thread狀態
func log(message: String) {
  let thread = Thread.current.isMainThread ? "Main" : "Background"
  print("\(thread) thread: \(message)")
}

// 用這個func來當作複雜的工作
func addNumbers(upTo range: Int) -> Int {
  log(message: "Adding numbers...")
  return (1...range).reduce(0, +)
}

let queue = DispatchQueue(label: "queue")

func execute<Result>(backgroundWork: @escaping () -> Result, mainWork: @escaping (Result) -> ()) {
  queue.async {
    // 將複雜的工作放到背景中執行
    let result = backgroundWork()
    DispatchQueue.main.async {
      // 執行完成才會到main thread中
      mainWork(result)
    }
  }
}

execute(backgroundWork: { addNumbers(upTo: 100) },
        mainWork:  { log(message: "The sum is \($0)") })

Weak self

• you declared self as unowned. However, this code isn’t safe! If, for some reason, the editor went out of scope before editTutorial had completed, self.feedback would crash when it eventually executed.

func editTutorial(_ tutorial: Tutorial) {
  queue.async() {
    // 這裡使用unowned會有問題, 改用weak
    [unowned self] in
    let feedback = self.feedback(for: tutorial)
    DispatchQueue.main.async {
      print(feedback)
    }
  }
}

The strong-weak pattern

  func editTutorial(_ tutorial: Tutorial) {
    queue.async() {
      [weak self] in
      // 把weak改成strong, 確保使用ok
      guard let self = self else {
        print("I no longer exist so no feedback for you!")
        return
      }
      DispatchQueue.main.async {
        print(self.feedback(for: tutorial))
      }
    }
  }
}

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. 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 strong weak pattern extends an object’s lifecycle for asynchronous closures.

• An escaping closure can be used after the corresponding function returns.