[Swift] delay : 지연시간 두고 코드 (반복) 실행하기 - Timer, asyncAfter

참고한 문서

The ultimate guide to Timer

Apple Developer Documentation

Why would a scheduledTimer fire properly when setup outside a block, but not within a block?

Swift에서 지연시간을 두고 코드를 (반복)실행하는 방법은 크게 두 가지가 있는데,

Timer와 DispatchQueue.main.asyncAfter 이다.

Note:
Before I start, I want to make it clear that there is a significant energy cost to using timers. We’ll look at ways to mitigate this, but broadly any kind of timer must wake the system from its idle state in order to trigger work, and that has an associated energy cost.
타이머를 사용하는 것은 상당한 에너지를 소모하는 작업임을 알아야 한다. 물론 완화하는 방법도 있다.

1. Timer

• 기본적인 반복 타이머 사용은 Timer.scheduledTimer 로 가능하다.

    // 셀렉터로 넘기기 - 타이머를 변수로 빼서 사용하기 좋다
    let timer = Timer.scheduledTimer(timeInterval: 1.0, target: self, selector: #selector(fireTimer), userInfo: nil, repeats: true)
    @objc func fireTimer() {
        print("Timer fired!")
    }
  
    // 또는 클로저로 반복수행 동작을 넘길 수도 있음 - inline으로 사용하기 좋다
    let timer = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { timer in
        print("Timer fired!")
    }

  • 타이머를 프로퍼티로 만들어 두면 나중에 종료할 때 유용하다.

• 반복하지 않는 타이머 - repeates 를 false로 한다.

  • 자동으로 스스로 invalidate된다.

    let timer1 = Timer.scheduledTimer(timeInterval: 1.0, target: self, selector: #selector(fireTimer), userInfo: nil, repeats: false)
    
    let timer2 = Timer.scheduledTimer(withTimeInterval: 1.0, repeats: false) { timer in
      print("Timer fired!")
    }

• 타이머 종료 : invalidate() 를 사용

    var runCount = 0
  
    Timer.scheduledTimer(withTimeInterval: 1.0, repeats: true) { timer in
        print("Timer fired!")
        runCount += 1
  
        if runCount == 3 {
            timer.invalidate()
        }
    }

• userInfo 인자에 정보를 추가해 타이머를 발동한 맥락을 저장할 수 있다. (Any? 타입)

    let context = ["user": "@twostraws"]
    Timer.scheduledTimer(timeInterval: 1.0, target: self, 
                                            selector: #selector(fireTimer), userInfo: context, repeats: true)
  
    @objc func fireTimer(timer: Timer) {
        guard let context = timer.userInfo as? [String: String] else { return }
        let user = context["user", default: "Anonymous"]
  
        print("Timer fired by \(user)!")
        runCount += 1
  
        if runCount == 3 {
            timer.invalidate()
        }
    }

• tolerance(허용 오차)

  • 시스템이 원래 지정한 시간과 허용 오차 사이의 어느 시점에든 타이머를 발동(trigger)할 수 있음을 의미

  • 타이머가 소모하는 에너지를 줄일 수 있는 쉬운 방법이다.

    • 시스템은 언제나 자동적으로 약간의 허용오차를 둔다.

  • tolerance를 지정하더라도 절대로 지정 시간 이전에 타이머를 발동하지는 않는다.

  • tolerance를 지정하더라도 타이머가 drift되진 않는다 (=다음 트리거가 더 빨리 발동되진 않는다)

    let timer = Timer.scheduledTimer(timeInterval: 1.0, target: self, selector: #selector(fireTimer), userInfo: nil, repeats: true)
    timer.tolerance = 0.2 // default값은 0임.

    As an example, consider a timer that was asked to execute every 1 second with a 0.5 second tolerance. It might run like this:

    After 1.0 seconds the timer fires.
    After 2.4 seconds the timer fires again. It’s 0.4 seconds late, but that’s still within our tolerance.
    After 3.1 seconds the timer fires again. This is only 0.7 seconds after our previous fire event, but each fire date is calculated from the original regardless of tolerance.
    After 4.5 seconds the timer fires again.
    And so on…

• runloop와 함께 작업하기

  • ✅ 사용자가 앱과 상호작용하는 중에는 Timer가 발동되지 않는다.

  • 왜? 우리는 암묵적으로 Timer를 런루프의 defaultRunLoopMode에서 생성하고 있음

  • 이것은 앱의 메인 스레드에서 유효하며, 사용자-UI 상호작용이 일어나는 중에는 일시중지된다. 상호작용이 끝나면 재개된다.

  • 문제를 해결하는 가장 쉬운 방법은 직접 선택한 런루프에 타이머를 추가하는 것이다.

    • 타이머가 메인 스레드에서 실행되고 있지 않다면 런루프를 갖지 못하기 때문.
    • 타이머는 반드시 런루프를 가져야 함. 메인 스레드는 하나의 런루프를 가지지만, 대부분의 백그라운드 스레드는 직접 추가하기 전에는 런루프를 갖지 않는다. - 참고
    • 타이머는 한번에 하나의 런루프에만 추가 가능. 단, 해당 런루프의 여러 런루프모드에는 추가할 수 있다.

  • .common : UI 사용 중에도 타이머가 발동될 수 있게 해 주는 런루프 모드.

    // 타이머 동작이 안될 시, 직접 런루프에 타이머를 더해 준다.
    let context = ["user": "@twostraws"]
    let timer = Timer(timeInterval: 1.0, target: self, selector: #selector(fireTimer), userInfo: context, repeats: true)
    RunLoop.current.add(timer, forMode: .common)
    
    // 또는 main스레드로 실행하는 방법도 있다
    DispatchQueue.main.async {
      self.timer = Timer.scheduledTimer(timeInterval: 1.0, target: self, selector: #selector(handleTimer(_:)), userInfo: nil, repeats: true)
    }

• 화면 변화에 타이머 동기화하기

  • CADisplayLink 를 사용하는 방법이 있다. 아래는 간단한 코드 예제. ( 참고 )

    let displayLink = CADisplayLink(target: self, selector: #selector(fireTimer))
    displayLink.add(to: .current, forMode: .default)

  • 타이머 발동 시, UI가 사용중임에도 화면과 연결된 메서드를 발동시키고 싶다면 .common 을 사용하라.

런루프 RunLoop

Apple Developer Documentation

Run Loops

RunLoop 런루프란??

• 런루프란 스레드와 연관된 기본 구조물의 일부이다.
• 런루프는 작업을 예약(schedule)하고, 들어오는 이벤트의 수신을 조정할 때 사용하는 이벤트 처리 루프이다.
• 런루프의 목적은 스레드가 일해야 할 때는 일하고, 일이 없을 때는 쉬도록 하는 것!
• 런루프 관리는 완전 자동이 아님. 필요할 때는 프로그래머가 직접 조정해줘야 함.
  • Cocoa와 Core Foundation은 런루프 객체를 제공한다.
• 메인 스레드를 포함해 각 스레드에는 모두 연관된 런루프 객체가 기본적으로 존재한다.
  • 따라서 런루프 객체를 직접 생성할 일은 없다.
• 메인 스레드의 런루프는 자동적으로 실행된다.
  • 앱 프레임워크가 앱 시작 프로세스의 일환으로 실행해 주는 것임.
• 메인이 아닌 보조 스레드들은 런루프를 명시적으로 ‘실행'해 주어야 동작한다.

✅ Command Line Tool(macOS) 프로젝트에서 타이머가 실행되지 않는 이유

• https://stackoverflow.com/questions/32140470/swift-nstimer-didnt-work

→ CLT에서는 메인 런루프가 기본적으로 실행되지 않음. 앱 프레임워크만이 메인 런루프를 기본적으로 실행 상태로 만들어 줄 뿐임. CLT에서는 명시적으로 개발자가 런루프의 실행을 해줘야 함.

• 타이머는 그것이 작동되기 위한 런루프가 필요한데, CLI 환경은 런루프가 기본적으로 실행되지 않는 상태이다. 명시적으로 실행이 필요함
  • iOS App 프로젝트는 앱 프레임워크가 메인 스레드의 런루프를 기본적으로 실행해 주기 때문에 따로 실행이 필요하지 않았던 것임.

방법1 - 시작과 종료 명시

• 시작 : CFRunLoopRun()
• 종료 : CFRunLoopStop()
• 현재 런루프 얻기 : CFRunLoopGetCurrent()

var count = 0

let timer = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { t in
    count += 1
    print(count)
    if count >= 5 {
        t.invalidate()
        CFRunLoopStop(CFRunLoopGetCurrent())
    }
}
// run 선언 이전에 선언한 타이머들만 동작한다.
CFRunLoopRun()

방법2 - run(until:) 사용

RunLoop의 run 메서드 중..

• run() 은 무한반복할 게 아니라면 쓰지 말아야 한다. RunLoop는 종료 메서드를 따로 제공하지 않는다. 실행 후 자동으로 종료되는 메서드를 이용해야 한다.
• run(until:) : 지정 시간까지 실행. 가장 많이 사용.

var count = 0

let timer = Timer.scheduledTimer(withTimeInterval: 1, repeats: true) { t in
    count += 1
    print(count)
    if count >= 5 {
        t.invalidate()
    }
}
while count < 5 {
    RunLoop.current.run(until: Date().addingTimeInterval(0.1))
}

2. DispatchQueue.main.asyncAfter(deadline:execute:)

Apple Developer Documentation

DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
    print("Timer fired!")
}

특정 시점에 작업 내용의 실행을 예약해 두고, 즉시 반환함.

• 반복이 아닌 단순 지연 코드를 작성할 때 유용.

  • 비동기로 실행되므로, asyncAfter를 반복실행해도 지정 시간 후에 반복되는 게 아니라 즉시 반복됨

  • 아래와 같이 사용해도 1초마다 반복되지 않는다.. 주의

    var isRunning = true
    var loop = 0
    while isRunning {
      print(Thread.current.isMainThread)
      print("asyncafter")
      DispatchQueue.main.asyncAfter(deadline: .now() + .seconds(1)) {
          print("asyncAfter!")
      }
      loop += 1
      if loop == 10 {
          isRunning = false
      }
    }

• Timer보다 간단하다.

• GCD를 활용한다.

DispatchSource.makeTimerSource(queue:)

• 백그라운드 큐에서 실행되는 타이머
• 런루프를 필요로 하지 않음

var timer: DispatchSourceTimer!

private func startTimer() {
    let queue = DispatchQueue(label: "com.domain.app.timer")
    timer = DispatchSource.makeTimerSource(queue: queue)
    timer.setEventHandler { [weak self] in
        // do something
    }
    timer.schedule(deadline: .now(), repeating: 1.0)
    timer.resume()
}