programing

dispatch_after - GCD (스위프트)

elseif 2023. 4. 9. 21:07

dispatch_after - GCD (스위프트)

Apple의 iBook을 살펴봤지만 정의를 찾을 수 없었습니다.

구조 좀 요?dispatch_after

dispatch_after(<#when: dispatch_time_t#>, <#queue: dispatch_queue_t?#>, <#block: dispatch_block_t?#>)

용 i i i i를 쓴다.dispatch_after너무 자주 구문을 쉽게 하기 위해 최상위 유틸리티 함수를 작성했습니다.

func delay(delay:Double, closure:()->()) {
    dispatch_after(
        dispatch_time(
            DISPATCH_TIME_NOW,
            Int64(delay * Double(NSEC_PER_SEC))
        ),
        dispatch_get_main_queue(), closure)
}

이제 이렇게 말할 수 있습니다.

delay(0.4) {
    // do stuff
}

와, 언어를 향상시킬 수 있는 언어군요.뭐가 더 좋을까?

Swift 3, Xcode 8 Seed 6 업데이트

호출 구문이 개선되었기 때문에 거의 신경 쓸 필요가 없을 것 같습니다.

func delay(_ delay:Double, closure:@escaping ()->()) {
    let when = DispatchTime.now() + delay
    DispatchQueue.main.asyncAfter(deadline: when, execute: closure)
}

구조에 대한 보다 명확한 개념:

dispatch_after(when: dispatch_time_t, queue: dispatch_queue_t, block: dispatch_block_t?)

dispatch_time_t는 입니다.UInt64 . 。dispatch_queue_t는 실제로는 입니다.NSObject단, 큐를 취득하려면 익숙한 GCD 메서드를 사용해야 합니다.이 블록은 스위프트 폐쇄입니다. 「」입니다.dispatch_block_t되어 있습니다.() -> Void에에니 , , ,에 해당합니다.() -> ().

사용 예:

let delayTime = dispatch_time(DISPATCH_TIME_NOW, Int64(1 * Double(NSEC_PER_SEC)))
dispatch_after(delayTime, dispatch_get_main_queue()) {
    print("test")
}

편집:

@matt의 매우 좋은 기능을 사용하는 것을 추천합니다.

편집 2:

Swift 3에는 GCD용 새로운 래퍼가 있습니다.여기를 참조해 주세요.https://github.com/apple/swift-evolution/blob/master/proposals/0088-libdispatch-for-swift3.md

원래의 예는 Swift 3에 다음과 같이 기술되어 있습니다.

let deadlineTime = DispatchTime.now() + .seconds(1)
DispatchQueue.main.asyncAfter(deadline: deadlineTime) {
    print("test")
}

, 이렇게 쓸 수 있어요.deadlineTime을 할 수 있습니다.DispatchTime.now() + 1.0 해서 같은 수 있습니다.+는 다음과는 다음과 같습니다).-

  • func +(time: DispatchTime, seconds: Double) -> DispatchTime
  • func +(time: DispatchWalltime, interval: DispatchTimeInterval) -> DispatchWalltime

''를 '''를 합니다.DispatchTimeInterval enum숫자만 적으면 초를 사용하는 것으로 가정됩니다.

스위프트 3 이상

이것은 Swift 3+로 매우 쉽고 우아합니다.

DispatchQueue.main.asyncAfter(deadline: .now() + 4.5) {
    // ...
}

오래된 답변:

1나노초 후에 실행되는 Cezary의 답변을 확대하기 위해서는 4초 반 후에 실행하기 위해 다음과 같이 해야 했습니다.

let delay = 4.5 * Double(NSEC_PER_SEC)
let time = dispatch_time(DISPATCH_TIME_NOW, Int64(delay))
dispatch_after(time, dispatch_get_main_queue(), block)

편집: 원래 코드가 약간 잘못된 것을 발견했습니다.NSEC_PER_SEC를 Double로 캐스팅하지 않으면 암묵적인 입력으로 컴파일 오류가 발생합니다.

만약 누군가가 더 최적의 해결책을 제안할 수 있다면 나는 그것을 듣고 싶다.

matt의 구문은 매우 훌륭합니다.블록을 무효로 할 필요가 있는 경우는, 다음과 같이 해 주세요.

typealias dispatch_cancelable_closure = (cancel : Bool) -> Void

func delay(time:NSTimeInterval, closure:()->Void) ->  dispatch_cancelable_closure? {

    func dispatch_later(clsr:()->Void) {
        dispatch_after(
            dispatch_time(
                DISPATCH_TIME_NOW,
                Int64(time * Double(NSEC_PER_SEC))
            ),
            dispatch_get_main_queue(), clsr)
    }

    var closure:dispatch_block_t? = closure
    var cancelableClosure:dispatch_cancelable_closure?

    let delayedClosure:dispatch_cancelable_closure = { cancel in
        if closure != nil {
            if (cancel == false) {
                dispatch_async(dispatch_get_main_queue(), closure!);
            }
        }
        closure = nil
        cancelableClosure = nil
    }

    cancelableClosure = delayedClosure

    dispatch_later {
        if let delayedClosure = cancelableClosure {
            delayedClosure(cancel: false)
        }
    }

    return cancelableClosure;
}

func cancel_delay(closure:dispatch_cancelable_closure?) {

    if closure != nil {
        closure!(cancel: true)
    }
}

다음과 같이 사용

let retVal = delay(2.0) {
    println("Later")
}
delay(1.0) {
    cancel_delay(retVal)
}

크레디트

위의 링크가 다운된 것 같습니다.Github의 오리지널 Objc 코드

Swift 3.0, Swift 4.0 및 Swift 5.0에서 가장 심플한 솔루션

func delayWithSeconds(_ seconds: Double, completion: @escaping () -> ()) {
    DispatchQueue.main.asyncAfter(deadline: .now() + seconds) { 
        completion()
    }
}

사용.

delayWithSeconds(1) {
   //Do something
}

Apple에는 Objective-C의 dispatch_after 스니펫이 있습니다.

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(<#delayInSeconds#> * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    <#code to be executed after a specified delay#>
});

다음은 Swift 3에 포팅된 동일한 스니펫입니다.

DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + <#delayInSeconds#>) {
  <#code to be executed after a specified delay#>
}

또 다른 방법은 다음과 같이 Double을 확장하는 것입니다.

extension Double {
   var dispatchTime: dispatch_time_t {
       get {
           return dispatch_time(DISPATCH_TIME_NOW,Int64(self * Double(NSEC_PER_SEC)))
       }
   }
}

그 후 다음과 같이 사용할 수 있습니다.

dispatch_after(Double(2.0).dispatchTime, dispatch_get_main_queue(), { () -> Void in
            self.dismissViewControllerAnimated(true, completion: nil)
    })

나는 Matt의 지연 기능을 좋아하지만 그냥 선호도 때문에 통과 폐쇄를 제한하고 싶다.

Swift 3.0의 경우

디스패치 큐

  DispatchQueue(label: "test").async {
        //long running Background Task
        for obj in 0...1000 {
            print("async \(obj)")
        }

        // UI update in main queue
        DispatchQueue.main.async(execute: { 
            print("UI update on main queue")
        })

    }

    DispatchQueue(label: "m").sync {
        //long running Background Task
        for obj in 0...1000 {
            print("sync \(obj)")
        }

        // UI update in main queue
        DispatchQueue.main.sync(execute: {
            print("UI update on main queue")
        })
    }

5초 후 디스패치

    DispatchQueue.main.after(when: DispatchTime.now() + 5) {
        print("Dispatch after 5 sec")
    }

, 특정 OP가 .NSTimer은 이 의 중복으로 이 질문의 중복으로 .NSTimer기서서대대대대대

NSTimer »dispatch_after

  • NSTimer이지만, 「」는 「고급」입니다.dispatch_after보다 낮은 레벨입니다.
  • NSTimer취소가 용이합니다. 중dispatch_after더 많은 코드를 써야 합니다.

: " "로 작업 지연"NSTimer

작성하다NSTimer★★★★★★ 。

var timer = NSTimer()

필요한 지연으로 타이머를 기동합니다.

// invalidate the timer if there is any chance that it could have been called before
timer.invalidate()
// delay of 2 seconds
timer = NSTimer.scheduledTimerWithTimeInterval(2.0, target: self, selector: #selector(delayedAction), userInfo: nil, repeats: false)

합니다('을 '이름을 '을'에 사용합니다).selector★★★★★★★★★★★★★★★★★★★★★」

func delayedAction() {
    print("Delayed action has now started."
}

메모들

  • 는, 「취소해 주세요」라고 됩니다.timer.invalidate().
  • 는, 「」를 사용합니다.repeats: true

  • , 「」를 할 .timervariable.instance instance instance instance 。하다

    NSTimer.scheduledTimerWithTimeInterval(2.0, target: self, selector: #selector(delayedAction), userInfo: nil, repeats: false)

  • 여기서 더 자세한 답을 보세요.

Swift 3.0 버전

다음 폐쇄 기능은 메인 스레드에서 지연된 후 몇 가지 작업을 수행합니다. 

func performAfterDelay(delay : Double, onCompletion: @escaping() -> Void){

    DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + delay, execute: {
       onCompletion()
    })
}

이 함수를 다음과 같이 호출합니다.

performAfterDelay(delay: 4.0) {
  print("test")
}

1) 이 메서드를 UIViewController Extension의 일부로 추가합니다.

extension UIViewController{
func runAfterDelay(delay: NSTimeInterval, block: dispatch_block_t) {
        let time = dispatch_time(DISPATCH_TIME_NOW, Int64(delay * Double(NSEC_PER_SEC)))
        dispatch_after(time, dispatch_get_main_queue(), block)
    }
}

VC에서 다음 메서드를 호출합니다.

    self.runAfterDelay(5.0, block: {
     //Add code to this block
        print("run After Delay Success")
    })

2)

performSelector("yourMethod Name", withObject: nil, afterDelay: 1)

3)

override func viewWillAppear(animated: Bool) {

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 2), dispatch_get_main_queue(), { () -> () in
    //Code Here
})

//컴팩트 폼

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, 2), dispatch_get_main_queue()) {
    //Code here
 }
}

Swift 5에서는 다음에서 사용합니다.

 DispatchQueue.main.asyncAfter(deadline: .now() + 0.2, execute: closure) 

// time gap, specify unit is second
DispatchQueue.main.asyncAfter(deadline: .now() + .seconds(2)) {
            Singleton.shared().printDate()
        }
// default time gap is second, you can reduce it
    DispatchQueue.main.asyncAfter(deadline: .now() + 0.2) {
          // just do it!
    }

여러 기능의 경우 이를 사용합니다.이것은 정적 기능이나 UI 업데이트에 애니메이션 또는 활동 로더를 사용하는 데 매우 유용합니다.

DispatchQueue.main.asyncAfter(deadline: .now() + 0.9) {
            // Call your function 1
            DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                // Call your function 2
            }
        }

예: tableView가 새로고침되기 전에 애니메이션을 사용합니다.애니메이션 후 다른 UI 업데이트도 가능합니다.

*// Start your amination* 
self.startAnimation()
DispatchQueue.main.asyncAfter(deadline: .now() + 0.9) {
                *// The animation will execute depending on the delay time*
                self.stopAnimation()
                DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
                    *// Now update your view*
                     self.fetchData()
                     self.updateUI()
                }
            }

이건 나한테 효과가 있었어.

스위프트 3:

let time1 = 8.23
let time2 = 3.42

// Delay 2 seconds

DispatchQueue.main.asyncAfter(deadline: .now() + 2.0) {
    print("Sum of times: \(time1 + time2)")
}

목표-C:

CGFloat time1 = 3.49;
CGFloat time2 = 8.13;

// Delay 2 seconds

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(2.0 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    CGFloat newTime = time1 + time2;
    NSLog(@"New time: %f", newTime);
});

Swift 3 & 4:

Dispatch Queue에서 확장을 생성하여 Dispatch Queue 비동기 After 함수를 내부적으로 사용하는 함수 지연을 추가할 수 있습니다.

extension DispatchQueue {
    static func delay(_ delay: DispatchTimeInterval, closure: @escaping () -> ()) {
        let timeInterval = DispatchTime.now() + delay
        DispatchQueue.main.asyncAfter(deadline: timeInterval, execute: closure)
    }
}

용도:

DispatchQueue.delay(.seconds(1)) {
    print("This is after delay")
}

사용률이 100% Swift인 코드를 지연시키는 또 다른 도우미는 지연된 코드를 실행할 다른 스레드를 선택적으로 선택할 수 있습니다.

public func delay(bySeconds seconds: Double, dispatchLevel: DispatchLevel = .main, closure: @escaping () -> Void) {
    let dispatchTime = DispatchTime.now() + seconds
    dispatchLevel.dispatchQueue.asyncAfter(deadline: dispatchTime, execute: closure)
}

public enum DispatchLevel {
    case main, userInteractive, userInitiated, utility, background
    var dispatchQueue: DispatchQueue {
        switch self {
        case .main:                 return DispatchQueue.main
        case .userInteractive:      return DispatchQueue.global(qos: .userInteractive)
        case .userInitiated:        return DispatchQueue.global(qos: .userInitiated)
        case .utility:              return DispatchQueue.global(qos: .utility)
        case .background:           return DispatchQueue.global(qos: .background)
        }
    }
}

이제 메인 스레드에서 코드를 다음과 같이 지연시킵니다.

delay(bySeconds: 1.5) { 
    // delayed code
}

코드를 다른 스레드로 지연시키는 경우:

delay(bySeconds: 1.5, dispatchLevel: .background) { 
    // delayed code that will run on background thread
}

보다 편리한 기능을 갖춘 프레임워크를 원하신다면 HandySwift를 확인해 보십시오.카르타고를 통해 프로젝트에 추가한 후 위의 예와 같이 사용할 수 있습니다.

import HandySwift    

delay(bySeconds: 1.5) { 
    // delayed code
}

저는 항상 무료 기능보다 확장 기능을 사용하는 것을 선호합니다.

스위프트 4 

public extension DispatchQueue {

  private class func delay(delay: TimeInterval, closure: @escaping () -> Void) {
    let when = DispatchTime.now() + delay
    DispatchQueue.main.asyncAfter(deadline: when, execute: closure)
  }

  class func performAction(after seconds: TimeInterval, callBack: @escaping (() -> Void) ) {
    DispatchQueue.delay(delay: seconds) {
      callBack()
    }
  }

}

다음과 같이 사용하세요.

DispatchQueue.performAction(after: 0.3) {
  // Code Here
}

swift에서 asyncAfter를 사용한 GCD 콜 지연

let delayQueue = DispatchQueue(label: "com.theappmaker.in", qos: .userInitiated)
let additionalTime: DispatchTimeInterval = .seconds(2)

지연은 **마이크로초, 밀리초, 나노초로 할 수 있습니다.

delayQueue.asyncAfter(deadline: .now() + 0.60) {
    print(Date())
}

delayQueue.asyncAfter(deadline: .now() + additionalTime) {
    print(Date())
}

Swift 4의 경우

다음 스니펫을 사용합니다.

    let delayInSec = 1.0
    DispatchQueue.main.asyncAfter(deadline: .now() + delayInSec) {
       // code here
       print("It works")
    }

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, (int64_t)(10 * NSEC_PER_SEC)), dispatch_get_main_queue(), ^{
    // ...
});

그dispatch_after(_:_:_:)함수는 다음 세 가지 파라미터를 취합니다.

지연
발송 대기 행렬
블록 또는 폐쇄

그dispatch_after(_:_:_:)함수는 특정 지연 후 함수에 전달되는 디스패치큐의 블록 또는 닫힘을 호출합니다.지연은 다음 명령어를 사용하여 생성됩니다.dispatch_time(_:_:)기능.Swift에서도 이 기능을 사용하고 있기 때문에 주의해 주십시오.

Raywenderlich Dispatch 튜토리얼을 진행하는 것이 좋습니다.

다음은 Swift의 asyncAfter 동기 버전입니다.

let deadline = DispatchTime.now() + .seconds(3)
let semaphore = DispatchSemaphore.init(value: 0)
DispatchQueue.global().asyncAfter(deadline: deadline) {
    dispatchPrecondition(condition: .onQueue(DispatchQueue.global()))
    semaphore.signal()
}

semaphore.wait()

비동기 1과 함께:

let deadline = DispatchTime.now() + .seconds(3)
DispatchQueue.main.asyncAfter(deadline: deadline) {
    dispatchPrecondition(condition: .onQueue(DispatchQueue.global()))
}

2.0초 후에 일부 UI 관련 작업을 수행하려면 이 코드를 사용합니다.

            let delay = 2.0
            let delayInNanoSeconds = dispatch_time(DISPATCH_TIME_NOW, Int64(delay * Double(NSEC_PER_SEC)))
            let mainQueue = dispatch_get_main_queue()

            dispatch_after(delayInNanoSeconds, mainQueue, {

                print("Some UI related task after delay")
            })

Swift 3.0 버전

다음 폐쇄 기능은 메인 스레드에서 지연된 후 몇 가지 작업을 수행합니다. 

func performAfterDelay(delay : Double, onCompletion: @escaping() -> Void){

    DispatchQueue.main.asyncAfter(deadline: DispatchTime.now() + delay, execute: {
       onCompletion()
    })
}

이 함수를 다음과 같이 호출합니다.

performAfterDelay(delay: 4.0) {
  print("test")
}

이제 Swift의 Grand Central Dispatch(GCD)에서는 비동기식 디스패치에 대한 통사적 설탕 이상의 기능을 제공합니다.

포드 파일 추가

pod 'AsyncSwift'

그럼 이렇게 쓰시면 됩니다.

let seconds = 3.0
Async.main(after: seconds) {
print("Is called after 3 seconds")
}.background(after: 6.0) {
print("At least 3.0 seconds after previous block, and 6.0 after Async code is called")
}

Swift 4에는 다음과 같은 간단한 방법이 있습니다.

Timer.scheduledTimer(withTimeInterval: 2, repeats: false) { (timer) in
    // Your stuff here
    print("hello")
}

를 보존하다current queue!

이 질문에 대한 적절한 답변 외에 불필요한 메인큐 조작(예를 들어 비동기 조작을 지연시키는 경우)을 방지하기 위해 현재 큐를 유지하는 것도 고려할 수 있습니다.

func after(_ delay: TimeInterval,
           perform block: @escaping ()->(),
           on queue: DispatchQueue = OperationQueue.current?.underlyingQueue ?? .main) { // So this `queue` preserves the current queue and defaulted to the `main`. Also the caller can pass in the desired queue explicitly
    queue.asyncAfter(deadline: .now() + delay, execute: block)
}

사용방법:

after(3) {
    // will be executed on the caller's queue
    print(Date())
}

지연 후 함수 또는 코드를 실행하려면 다음 방법을 사용합니다.

DispatchQueue.main.asyncAfter(deadline: .now() + 'secondsOfDelay') {
        your code here...
    }

예 - 이 예에서 기능은getShowMovies1초 후에 실행됩니다.

DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
        self.getShowMovies()
    }

언급URL : https://stackoverflow.com/questions/24034544/dispatch-after-gcd-in-swift

'programing' 카테고리의 다른 글

git 저장 해제  (0) 2023.04.09
SQL 테이블에서 중복 값 찾기  (0) 2023.04.09
C#의 String과 String의 차이점은 무엇입니까?  (0) 2023.04.09
HTML5 localStorage/sessionStorage에 개체를 저장하는 방법  (0) 2023.04.09
SQL Server 2008 Windows 인증 로그인 오류:로그인이 신뢰할 수 없는 도메인입니다.  (0) 2023.04.09

'programing'의 다른글

  • 현재글dispatch_after - GCD (스위프트)

관련글

댓글

티스토리툴바