https://baked-corn.tistory.com/30
https://velog.io/@msi753/ARC

ARC 시스템

참조하는 변수를 카운트하는 시스템
아웃렛 변수가 weak타입을 기본으로 사용하는 이유는

• 1. 메모리 부족
  • weak 타입일 때, 메모리가 부족하면 ViewController의 didReceiveMemoryWarning() 메소드가 호출되면서 메인뷰가 nil이 되도록 처리가 되고, weak 타입으로 선언된 모든 변수는 카운트가 0이 되면서 메모리가 해제된다.
  • strong 타입일 때, nil 처리가 되더라도 카운트가 0이 아니면 메모리가 해제되지 않고 메모리 누수가 발생한다.
• 2. 순환 참조 오류
     서로 Strong으로 강한 참조를 하고 있으면 A를 제거하려면 B를 먼저 제거해야 하고, B를 제거하려면 A를 먼저 제거해야하는 논리적 모순이 발생하기 때문이다.

Strong & Weak

strong과 weak는 어떻게 다른가요? 🎈
한 아이가 풍선을 들고있는 상황을 가정해보자.
아이가 풍선을 들고 있는 것이 strong,
풍선과 아이의 연결관계가 weak이다.

Strong

기본적인 클래스(reference type)는 강한 참조이다.
부모 객체가 자식 객체를 참조하면 카운트가 1이 증가하고, 자식 객체가 부모 객체를 참조하면 카운트가 1이 증가한다.
순환참조를 하기 때문에 메모리 누수가 발생할 수 밖에 없다.

예제

class TestClass{
    var testClass: TestClass? = nil
    init(){
        print("init")
    }
    deinit(){
        print("deinit")
    }
}

var testClass1: TestClass? = TestClass()
var testClass2: TestClass? = TestClass()

testClass1?.testClass = testClass2
testClass2?.testClass = testClass1

testClass1 = nil
testClass2 = nil

>> init
>> init

deinit하지 않음

메모리 해제 불가능(메모리 누수)

weak

부모가 자식을 강하게 참조하면 카운트가 1 증가하지만, 자식은 부모를 약하게 참조하고 있기 때문에 카운트가 증가하지 않는다

예제

class TestClass{
    weak var testClass: TestClass? = nil  // 이제 이 참조는 약한 참조이다!
    init(){
        print("init")
    }
    deinit(){
        print("deinit")
    }
}

var testClass1: TestClass? = TestClass()
var testClass2: TestClass? = TestClass()

testClass1?.testClass = testClass2
testClass2?.testClass = testClass1

testClass1 = nil
testClass2 = nil

>> init
>> init
>> deinit
>> deinit

객체의 메모리가 해제된 후 그에 대응하는 변수는 자동으로 nil이 될 것입니다.
optional 타입만이 nil값이 될 수 있기 때문에 모든 weak 참조 변수는 반드시 optional 타입이어야 합니다.

[weak self] vs unowned

[weak self]

class ViewController: UIViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
    }
    
    override func viewDidAppear(_ animated: Bool) {
        super.viewDidAppear(animated)
        
        let alert = UIAlertController(title: "Title", message: "Message", preferredStyle: .alert)
        alert.addAction(UIAlertAction(title: "Done", style: .cancel, handler: { [weak self] _ in
            self?.doSomething()
        }))
        present(alert, animated: true)
    }
    
    private func doSomething() {
        print("doSomething")
    }
}

• 루프 발생(순환참조 오류)로 메모리 누수가 발생한다
  클로저 안에 self를 사용하면 scope's life 동안 self를 strong reference하게됩니다.
  ViewController위에 UIAlertController를 올리고 ( 강한참조: ViewController -> UIAlertController),
  UIAlertController가 완료되면 self.doSomething을 실행시키는데 self는 ViewController를 가리킨다 ( 강한참조: UIAlertController -> ViewController)

• [weak self]로 순환 참조 루프를 없앤다
  (UIAlertController -> ViewController)를 옵셔널로 약한 참조로 만들어 루프를 제거한다

  [weak self] _ in     // [weak self]
  self?.doSomething()  // 옵셔널로 변경

• 클로저에서 [weak self]를 사용할 때,
  self를 옵셔널로 만들기 때문에, 위처럼 self?.data = data처럼 쓸 수도 있지만,
  guard let을 사용해 일시적으로 클로저의 시작에 self를 strong reference해줄 수도 있다.

    private var data: Data?
    
    private func getData(string: String, completion: ((Data?)->Void)) {
        completion(nil)
    }
    
    func foo() {
        getData(string: "") { [weak self] data in
            guard let strongSelf = self else {
                return
            }
            strongSelf.data = data
            // 아니면 self?.data = data로 썼을 거다
        }
    }

• delegate 패턴에서 weak를 사용할 때

protocol SomeDelegate: AnyObject {
    func didTapThing()
}

//Foo가 풍선을 들고있는 어린아이
//ViewController가 풍선
class Foo: SomeDelegate {
    init() {
        let vc = ViewController()   // Foo->ViewController 강한참조
        vc.delegate = self          // ViewController->Foo 강한참조
    }
    
    public func didTapThing() {
        //
    }
}

class ViewController: UIViewController {
    
    weak var delegate: SomeDelegate?
}

Unowned

unowned로 선언된 변수는 절대 nil이 될 수 없습니다. 그러므로 unowned 변수는 optional로 선언되어서는 절대 안됩니다. 마치 unwrapping하는 것과 같습니다. unowned는 해제된 메모리 영역을 접근하지 않는다는 확실한 경우만 사용해야한다는 뜻입니다. 그렇지 않으면 앱이 crash합니다.
해당 변수가 가리키는 객체의 메모리가 해제된 이후에는 해당 영역을 가리키지 않는다는 확신이 있다면 당신은 unowned를 사용할 수 있습니다.

  let changeColorToRed = DispatchWorkItem { [unowned self] in
  	guard let self = self else { return }
    self.view.backgroundColor = .red
  }

• Escaping vs non-escaping closures
  • Non-escaping closures는 scope안에서 즉시 실행된다. 저장되거나 나중에 실행될 수 없다.
    • strong reference cycle을 유발하지 않으니 weak나 unowned를 사용할 필요가 없다
  • Escaping closures는 아래와 같은 경우에만 weak나 unowned를 사용한다.
    + property에 저장되거나 다른 클로저로 넘겨질 때
    + 클로저 안에 object(such as self)가 strong reference를 유지할 때
    

---

---

---

Retain Cycle 시나리오

1. Delegate

자식 뷰 컨트롤러를 갖고 있는 부모 뷰 컨트롤러
부모 뷰 컨트롤러가 pop됐을 때 메모리 누수 방지

class ParentViewController: UIViewController, ChildViewControllerProtocol: class{
    let childViewController = ChildViewController()
    func prepareChildViewController(){
        childViewController.delegate = self
    }
}

protocol ChildViewControllerProtocol {
    // important functions
}

class ChildViewController: UIViewController {
    //var delegate: ChildViewControllerProtocol? 여기!
    weak var delegate: ChildViewControllerProtocol?
}

UITableView에서의 예시

weak public var dataSource: UITableViewDataSource?
weak public var delegate: UITableViewDelegate?

2. Closure: class와 마찬가지로 reference type(강한 참조)

TestClass 객체의 내부에서 Closure로, Closure에서 TestClass객체로 강한 참조
-> weak self를 capture해줌으로써 해결

class TestClass{
    var aBlock: (()->())? = nil
    let aConstant = 5
    
    init(){
        print("init")
        aBlock = { [weakself] in	// 여기!
        //aBlock = {
            print(self.aConstant)
        }
    }
    deinit(){
        print("deinit")
    }
}

var testClass: TestClass? = TestClass()
testClass = nil

closure 블록을 locally하게 사용한다면 self를 weak하게 capture할 필요가 없음
-> 예시 UIView.animateWithDuration

class TestClass {
    let aConstant = 5
    
    init() {
        print("init")
        let aBlock = {
            print(self.aConstant)
        }
    }
    deinit {
        print("deinit")
    }   
}
var testClass: TestClass? = TestClass()
testClass = nil

class TestClass{
    let aConstant = 5
    
    init(){
        print("init")
    }
    deinit(){
        print("deinit")
    }
    func doSomething(){
        UIView.animate(withDuration: 5){
            let aConstant = self.aConstant
            
            // fancy animation ... .        
        }   
    }
}

var testClass: TestClass? = TestClass()
testClass?.doSomething()
testClass = nil

Detecting retain cycles by using log messages in deinit

모든 View Controller마다 이러한 메소드를 작성해주는 것이 좋습니다

let timer = Timer.scheduledTimer(withTimeInterval: 0.01, repeats: true, block: { [unowned self] (timer: Timer) in
	if self.progressSlider.isTracking { return }
    
	self.progressSlider.value = Float(self.player.currentTime)
})

프로젝트 MusicPlayer를 만들면서 unowned self를 이해하지 못해서 검색했다.
메모리를 자동으로 관리해주는 ARC와 연관된 부분이며, 약한 참조를 의미한다.
weak와 unowned가 다른 점은 optional, nil이 될 수 없고, 해제 후 반드시 해당 영역을 가리키는 일이 없어야 한다는 것이다.
전역적으로 사용하는 Timer, 클래스와 마찬가지로 강한 참조를 하는 클로저의 성질 때문에,
클로저 블록을 weak하게 capture한 것이다.