<div id="readability-page-1" class="page"><div><h2 id="탈출-클로저escaping-closure">탈출 클로저(Escaping Closure)</h2>
오늘은 탈출 클로저에 대해 알아보겠습니다. 
탈출 클로저는 함수가 끝난 뒤에도 실행될 수 있는 클로저를 말해요. 
원래 함수의 매개변수로 전달된 클로저는 함수가 종료되면 메모리에서 사라지는데, 탈출 클로저는 함수가 끝나도 메모리에 남아 있어서 외부에서 계속 사용할 수 있습니다. 
이 특징 때문에 주로 비동기 작업에서 많이 사용되고, <code>@escaping</code> 키워드를 사용해 선언합니다.
<pre><code>var completionHandlers: [() -&gt; Void] = []
func someFunctionWithEscapingClosure(completionHandler: @escaping () -&gt; Void) {
 completionHandlers.append(completionHandler)
}
</code></pre>
여기서 보시면, 탈출 클로저가 <code>completionHandlers</code> 배열에 추가되었어요. 이 덕분에 함수가 종료된 후에도 클로저가 실행될 수 있는 거죠. 
만약 <code>@escaping</code> 키워드를 사용하지 않으면 컴파일 에러가 나겠죠?
<h2 id="클로저의-self-캡처">클로저의 <code>self</code> 캡처</h2>
클로저는 함수나 메서드 내부의 변수나 객체를 캡처해서 사용할 수 있어요. 
예를 들어, 클로저가 <code>self</code>를 캡처하면 그 객체의 상태를 유지하거나 변경할 수 있죠. 그런데 탈출 클로저는 함수 실행이 끝난 후에도 계속 살아있기 때문에, <code>self</code>를 명시적으로 캡처해줘야 해요. 이렇게 해야 강한 참조 사이클, 즉 메모리 누수를 방지할 수 있습니다.
<pre><code>func someFunctionWithNonescapingClosure(closure: () -&gt; Void) {
 closure()
}

class SomeClass {
 var x = 10
 func doSomething() {
 someFunctionWithEscapingClosure { self.x = 100 }
 someFunctionWithNonescapingClosure { x = 200 }
 }
}

let instance = SomeClass()
instance.doSomething()
print(instance.x)
// Prints "200"

completionHandlers.first?()
print(instance.x)
// Prints "100"
</code></pre>
위 예제를 보면, 비탈출 클로저는 함수 내부에서만 실행되기 때문에 <code>self</code>를 굳이 명시하지 않아도 됩니다. 하지만 탈출 클로저는 <code>self</code>를 명시적으로 캡처해야 해요. 이렇게 해야 강한 참조 사이클을 피할 수 있답니다.
<h2 id="탈출-클로저와-메모리-관리">탈출 클로저와 메모리 관리</h2>
<h2 id="참조-사이클과-메모리-누수">참조 사이클과 메모리 누수</h2>
여기서 중요한 개념 하나가 더 나옵니다. 클로저가 <code>self</code>를 강하게 잡고 있으면, 강한 참조 사이클이 발생할 수 있고, 이로 인해 메모리 누수가 생길 수 있어요. 그래서 이 문제를 해결하려면 <code>self</code>를 약한 참조(<code>weak</code>)나 비소유 참조(<code>unowned</code>)로 선언해야 합니다.
<pre><code>class SomeClass {
 var x = 10

 func doSomething() {
 someFunctionWithEscapingClosure { [weak self] in
 guard let self = self else { return }
 self.x = 100
 }
 }
}
</code></pre>
여기서는 <code>weak</code> 참조를 사용했어요. 이렇게 하면 클로저가 <code>self</code>를 참조해도 강한 참조가 생기지 않아서 참조 사이클을 막을 수 있어요. <code>weak</code> 참조를 사용할 때는 <code>self</code>가 해제될 가능성을 염두에 두고, 클로저 내부에서 <code>self</code>가 nil이 아닌지 확인해주는 게 중요해요.
반면에 <code>unowned</code> 참조는 클로저가 실행될 때 <code>self</code>가 반드시 존재할 것이라고 확신할 수 있을 때 사용해요. <code>unowned</code>는 Optional이 아니라 성능이 조금 더 좋지만, 만약 객체가 해제된 후에 <code>unowned</code> 참조에 접근하면 런타임 에러가 발생할 수 있다는 점, 꼭 기억하세요.
<h3 id="weak와-unowned-참조의-사용-사례">weak와 unowned 참조의 사용 사례</h3>
<h3 id="weak-참조">weak 참조</h3>
<code>weak</code> 참조는 주로 객체가 해제될 가능성이 있을 때 사용해요. 예를 들어, 델리게이트 패턴에서는 주 객체와 델리게이트 객체 간의 강한 참조 사이클을 피하기 위해 <code>weak</code> 참조를 많이 사용해요.
<pre><code>protocol MyDelegate: AnyObject {
 func didSomething()
}

class MyClass {
 weak var delegate: MyDelegate?

 func performAction() {
 delegate?.didSomething()
 }
}

class ViewController: UIViewController, MyDelegate {
 let myClass = MyClass()

 override func viewDidLoad() {
 super.viewDidLoad()
 myClass.delegate = self
 }

 func didSomething() {
 print("Delegate method called")
 }
}
</code></pre>
이처럼 델리게이트 패턴에서는 <code>weak</code> 참조가 필수적이에요. 델리게이트 객체가 해제되더라도 주 객체가 이를 강하게 참조하지 않도록 하기 위해서죠.
또한, 비동기 작업에서 <code>self</code>가 해제될 가능성이 있다면 <code>weak</code> 참조를 사용하는 것이 안전합니다.
<pre><code>class SomeClass {
 var x = 10

 func performOperation() {
 someFunctionWithEscapingClosure { [weak self] in
 self?.x = 100
 }
 }
}
</code></pre>
마찬가지로, 타이머와 같은 비동기 작업에서도 <code>weak</code> 참조를 활용해 메모리 관리가 필요합니다.
<pre><code>class TimerClass {
 var timer: Timer?

 func startTimer() {
 timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
 self?.doSomething()
 }
 }

 func doSomething() {
 print("Timer fired!")
 }

 deinit {
 timer?.invalidate()
 print("TimerClass is being deinitialized")
 }
}

var timerInstance: TimerClass? = TimerClass()
timerInstance?.startTimer()

// 나중에 timerInstance를 nil로 설정하면 TimerClass가 해제됩니다.
timerInstance = nil
</code></pre>
이 예제에서는 <code>weak</code> 참조를 사용해 <code>self</code>가 nil이 될 가능성을 대비하고 있어요. 이를 통해 메모리 누수를 예방할 수 있죠.
<h3 id="unowned-참조">unowned 참조</h3>
<code>unowned</code> 참조는 객체가 해제되지 않을 것이 확실할 때 사용해요. 예를 들어, 객체와 클로저의 생명주기가 동일하거나, <code>self</code>가 반드시 존재한다고 확신할 수 있을 때 적합합니다.
<pre><code>class Customer {
 let name: String
 var card: CreditCard?

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

class CreditCard {
 let number: String
 unowned let customer: Customer

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

let john = Customer(name: "John Appleseed")
let card = CreditCard(number: "1234-5678-9012-3456", customer: john)

john.card = card
</code></pre>
이 예제에서는 Customer와 CreditCard가 서로의 생명주기를 공유하므로 <code>unowned</code> 참조를 사용하는 것이 적절합니다.
또한, 타이머와 같은 비동기 작업에서도 <code>self</code>가 반드시 존재한다고 확신할 수 있는 경우라면 <code>unowned</code> 참조를 사용할 수 있어요.
<pre><code>class TimerClass {
 var timer: Timer?

 func startTimer() {
 timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [unowned self] _ in
 self.doSomething()
 }
 }

 func doSomething() {
 print("Timer fired!")
 }

 deinit {
 timer?.invalidate()
 print("TimerClass is being deinitialized")
 }
}

var timerInstance: TimerClass? = TimerClass()
timerInstance?.startTimer()

// timerInstance를 nil로 설정하면 TimerClass가 해제됩니다.
timerInstance = nil
</code></pre>
여기서는 <code>unowned</code> 참조를 사용했어요. <code>self</code>가 클로저 실행 중에 해제될 가능성이 전혀 없다면, <code>unowned</code>를 사용하는 것이 성능 면에서 더 효율적입니다.
<h3 id="weak와-unowned-참조-선택-가이드">weak와 unowned 참조 선택 가이드</h3>
마지막으로, <code>weak</code>와 <code>unowned</code> 참조를 언제 사용해야 할지 간단히 정리해볼게요:
<ul>
<li><code>weak</code> 참조: 객체가 해제될 가능성이 있는 경우 사용해요. 객체가 해제되면 자동으로 nil로 설정됩니다.</li>
<li><code>unowned</code> 참조: 객체가 해제되지 않을 것이라고 확신할 수 있을 때 사용해요. nil이 될 가능성이 없어서 Optional 언래핑이 필요하지 않아요.</li>
</ul>
만약 <code>weak</code>와 <code>unwoned</code> 중에서 어떤 것을 사용될지 고민된다면, 일반적으로는 <code>weak</code>로 작성하는 것이 좋습니다. 메모리 관리에 있어 안정성을 제공하고 디버깅이 좀 더 쉽기 때문이죠.
<h2 id="내용-요약">내용 요약</h2>
<ol>
<li>탈출 클로저(Escaping Closure): 
탈출 클로저는 함수 종료 후에도 실행 가능한 클로저로, 비동기 작업에서 주로 사용되며 <code>@escaping</code> 키워드를 사용해 선언.</li>
<li>클로저의 <code>self</code> 캡처: 
클로저는 내부 변수나 객체를 캡처하며, 탈출 클로저는 <code>self</code>를 명시적으로 캡처해 강한 참조 사이클을 방지해야 함.</li>
<li>참조 사이클과 메모리 누수: 
클로저가 <code>self</code>를 강하게 참조하면 메모리 누수가 발생할 수 있으며, 이를 방지하기 위해 <code>weak</code> 또는 <code>unowned</code> 참조를 사용.</li>
<li><code>weak</code> 참조 사용 사례: 
델리게이트 패턴과 탈출 클로저에서 <code>self</code>가 해제될 가능성이 있을 때 <code>weak</code> 참조 사용. 
- 타이머와 같은 비동기 작업에서 <code>weak</code> 참조로 안전하게 메모리 관리.</li>
<li><code>unowned</code> 참조 사용 사례: 
생명주기가 일치하는 객체 관계나, 타이머와 같은 비동기 작업에서 <code>self</code>가 반드시 존재할 때 <code>unowned</code> 참조 사용.</li>
<li><code>weak</code>와 <code>unowned</code> 참조 선택 가이드: 
<code>weak</code>은 참조 대상이 해제될 가능성이 있을 때, <code>unowned</code>는 참조 대상이 해제되지 않을 때 사용.</li>
</ol>
<hr>
<blockquote>
출처 
<a href="https://bbiguduk.gitbook.io/swift/language-guide-1/closures#escaping-closures">https://bbiguduk.gitbook.io/swift/language-guide-1/closures#escaping-closures</a>
</blockquote></div></div>

jwlee010523.log

탈출 클로저(Escaping Closure)
오늘은 탈출 클로저에 대해 알아보겠습니다.
탈출 클로저는 함수가 끝난 뒤에도 실행될 수 있는 클로저를 말해요.
원래 함수의 매개변수로 전달된 클로저는 함수가 종료되면 메모리에서 사라지는데, 탈출 클로저는 함수가 끝나도 메모리에 남아 있어서 외부에서 계속 사용할 수 있습니다.
이 특징 때문에 주로 비동기 작업에서 많이 사용되고, @escaping 키워드를 사용해 선언합니다.
var completionHandlers: [() -> Void] = []
func someFunctionWithEscapingClosure(completionHandler: @escaping () -> Void) {
    completionHandlers.append(completionHandler)
}
여기서 보시면, 탈출 클로저가 completionHandlers 배열에 추가되었어요. 이 덕분에 함수가 종료된 후에도 클로저가 실행될 수 있는 거죠.
만약 @escaping 키워드를 사용하지 않으면 컴파일 에러가 나겠죠?
클로저의 self 캡처
클로저는 함수나 메서드 내부의 변수나 객체를 캡처해서 사용할 수 있어요.
예를 들어, 클로저가 self를 캡처하면 그 객체의 상태를 유지하거나 변경할 수 있죠. 그런데 탈출 클로저는 함수 실행이 끝난 후에도 계속 살아있기 때문에, self를 명시적으로 캡처해줘야 해요. 이렇게 해야 강한 참조 사이클, 즉 메모리 누수를 방지할 수 있습니다.
func someFunctionWithNonescapingClosure(closure: () -> Void) {
    closure()
}
class SomeClass {
    var x = 10
    func doSomething() {
        someFunctionWithEscapingClosure { self.x = 100 }
        someFunctionWithNonescapingClosure { x = 200 }
    }
}
let instance = SomeClass()
instance.doSomething()
print(instance.x)
// Prints "200"
completionHandlers.first?()
print(instance.x)
// Prints "100"
위 예제를 보면, 비탈출 클로저는 함수 내부에서만 실행되기 때문에 self를 굳이 명시하지 않아도 됩니다. 하지만 탈출 클로저는 self를 명시적으로 캡처해야 해요. 이렇게 해야 강한 참조 사이클을 피할 수 있답니다.
탈출 클로저와 메모리 관리
참조 사이클과 메모리 누수
여기서 중요한 개념 하나가 더 나옵니다. 클로저가 self를 강하게 잡고 있으면, 강한 참조 사이클이 발생할 수 있고, 이로 인해 메모리 누수가 생길 수 있어요. 그래서 이 문제를 해결하려면 self를 약한 참조(weak)나 비소유 참조(unowned)로 선언해야 합니다.
class SomeClass {
    var x = 10
    func doSomething() {
        someFunctionWithEscapingClosure { [weak self] in
            guard let self = self else { return }
            self.x = 100
        }
    }
}
여기서는 weak 참조를 사용했어요. 이렇게 하면 클로저가 self를 참조해도 강한 참조가 생기지 않아서 참조 사이클을 막을 수 있어요. weak 참조를 사용할 때는 self가 해제될 가능성을 염두에 두고, 클로저 내부에서 self가 nil이 아닌지 확인해주는 게 중요해요.
반면에 unowned 참조는 클로저가 실행될 때 self가 반드시 존재할 것이라고 확신할 수 있을 때 사용해요. unowned는 Optional이 아니라 성능이 조금 더 좋지만, 만약 객체가 해제된 후에 unowned 참조에 접근하면 런타임 에러가 발생할 수 있다는 점, 꼭 기억하세요.
weak와 unowned 참조의 사용 사례
weak 참조
weak 참조는 주로 객체가 해제될 가능성이 있을 때 사용해요. 예를 들어, 델리게이트 패턴에서는 주 객체와 델리게이트 객체 간의 강한 참조 사이클을 피하기 위해 weak 참조를 많이 사용해요.
protocol MyDelegate: AnyObject {
    func didSomething()
}
class MyClass {
    weak var delegate: MyDelegate?
    func performAction() {
        delegate?.didSomething()
    }
}
class ViewController: UIViewController, MyDelegate {
    let myClass = MyClass()
    override func viewDidLoad() {
        super.viewDidLoad()
        myClass.delegate = self
    }
    func didSomething() {
        print("Delegate method called")
    }
}
이처럼 델리게이트 패턴에서는 weak 참조가 필수적이에요. 델리게이트 객체가 해제되더라도 주 객체가 이를 강하게 참조하지 않도록 하기 위해서죠.
또한, 비동기 작업에서 self가 해제될 가능성이 있다면 weak 참조를 사용하는 것이 안전합니다.
class SomeClass {
    var x = 10
    func performOperation() {
        someFunctionWithEscapingClosure { [weak self] in
            self?.x = 100
        }
    }
}
마찬가지로, 타이머와 같은 비동기 작업에서도 weak 참조를 활용해 메모리 관리가 필요합니다.
class TimerClass {
    var timer: Timer?
    func startTimer() {
        timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [weak self] _ in
            self?.doSomething()
        }
    }
    func doSomething() {
        print("Timer fired!")
    }
    deinit {
        timer?.invalidate()
        print("TimerClass is being deinitialized")
    }
}
var timerInstance: TimerClass? = TimerClass()
timerInstance?.startTimer()
// 나중에 timerInstance를 nil로 설정하면 TimerClass가 해제됩니다.
timerInstance = nil
이 예제에서는 weak 참조를 사용해 self가 nil이 될 가능성을 대비하고 있어요. 이를 통해 메모리 누수를 예방할 수 있죠.
unowned 참조
unowned 참조는 객체가 해제되지 않을 것이 확실할 때 사용해요. 예를 들어, 객체와 클로저의 생명주기가 동일하거나, self가 반드시 존재한다고 확신할 수 있을 때 적합합니다.
class Customer {
    let name: String
    var card: CreditCard?
    init(name: String) {
        self.name = name
    }
}
class CreditCard {
    let number: String
    unowned let customer: Customer
    init(number: String, customer: Customer) {
        self.number = number
        self.customer = customer
    }
}
let john = Customer(name: "John Appleseed")
let card = CreditCard(number: "1234-5678-9012-3456", customer: john)
john.card = card
이 예제에서는 Customer와 CreditCard가 서로의 생명주기를 공유하므로 unowned 참조를 사용하는 것이 적절합니다.
또한, 타이머와 같은 비동기 작업에서도 self가 반드시 존재한다고 확신할 수 있는 경우라면 unowned 참조를 사용할 수 있어요.
class TimerClass {
    var timer: Timer?
    func startTimer() {
        timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { [unowned self] _ in
            self.doSomething()
        }
    }
    func doSomething() {
        print("Timer fired!")
    }
    deinit {
        timer?.invalidate()
        print("TimerClass is being deinitialized")
    }
}
var timerInstance: TimerClass? = TimerClass()
timerInstance?.startTimer()
// timerInstance를 nil로 설정하면 TimerClass가 해제됩니다.
timerInstance = nil
여기서는 unowned 참조를 사용했어요. self가 클로저 실행 중에 해제될 가능성이 전혀 없다면, unowned를 사용하는 것이 성능 면에서 더 효율적입니다.
weak와 unowned 참조 선택 가이드
마지막으로, weak와 unowned 참조를 언제 사용해야 할지 간단히 정리해볼게요:
weak 참조: 객체가 해제될 가능성이 있는 경우 사용해요. 객체가 해제되면 자동으로 nil로 설정됩니다.
unowned 참조: 객체가 해제되지 않을 것이라고 확신할 수 있을 때 사용해요. nil이 될 가능성이 없어서 Optional 언래핑이 필요하지 않아요.
만약 weak와 unwoned 중에서 어떤 것을 사용될지 고민된다면, 일반적으로는 weak로 작성하는 것이 좋습니다. 메모리 관리에 있어 안정성을 제공하고 디버깅이 좀 더 쉽기 때문이죠.
내용 요약
탈출 클로저(Escaping Closure):
탈출 클로저는 함수 종료 후에도 실행 가능한 클로저로, 비동기 작업에서 주로 사용되며 @escaping 키워드를 사용해 선언.
클로저의 self 캡처:
클로저는 내부 변수나 객체를 캡처하며, 탈출 클로저는 self를 명시적으로 캡처해 강한 참조 사이클을 방지해야 함.
참조 사이클과 메모리 누수:
클로저가 self를 강하게 참조하면 메모리 누수가 발생할 수 있으며, 이를 방지하기 위해 weak 또는 unowned 참조를 사용.
weak 참조 사용 사례:
델리게이트 패턴과 탈출 클로저에서 self가 해제될 가능성이 있을 때 weak 참조 사용.
타이머와 같은 비동기 작업에서 weak 참조로 안전하게 메모리 관리.
unowned 참조 사용 사례:
생명주기가 일치하는 객체 관계나, 타이머와 같은 비동기 작업에서 self가 반드시 존재할 때 unowned 참조 사용.
weak와 unowned 참조 선택 가이드:
weak은 참조 대상이 해제될 가능성이 있을 때, unowned는 참조 대상이 해제되지 않을 때 사용.
출처
https://bbiguduk.gitbook.io/swift/language-guide-1/closures#escaping-closures

탈출 클로저(Escaping Closure)

댓글