program tip

dispatch_after-Swift의 GCD?

radiobox 2020. 10. 4. 10:47

dispatch_after-Swift의 GCD?

Apple 에서 iBook 을 살펴 보았지만 정의를 찾을 수 없습니다.

누군가의 구조를 설명 할 수 있습니까 dispatch_after?

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

구조에 대한보다 명확한 아이디어 :

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

dispatch_time_t입니다 UInt64. 는 dispatch_queue_t실제로 별칭 유형입니다 NSObject,하지만 당신은 대기열을 얻을 수 있도록 친숙한 GCD 방법을 사용해야합니다. 블록은 Swift 클로저입니다. 구체적 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의 정말 멋진 delay기능을 사용하는 것이 좋습니다 .

편집 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숫자 만 쓰면 초를 사용하는 것으로 간주됩니다.

나는 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)
}

Swift 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)
    })

나는 매트의 딜레이 기능을 좋아하지만 선호도에서 나는 클로저 전달을 제한하고 싶습니다.

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")
    }

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")
    })

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

삼)

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
 }
}

OP의 원래 질문은 아니지만 특정 NSTimer관련 질문이이 질문의 중복으로 표시되었으므로 NSTimer여기 에 답변을 포함하는 것이 좋습니다.

`NSTimer` vs `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.
취소 할 필요가없는 일회성 이벤트가있는 timer경우 인스턴스 변수 를 만들 필요가 없습니다 . 다음으로 충분합니다.
```
NSTimer.scheduledTimerWithTimeInterval(2.0, target: self, selector: #selector(delayedAction), userInfo: nil, repeats: false) 
```
여기에 내 자세한 답변을 참조 하십시오 .

여러 기능의 경우 이것을 사용하십시오. 이것은 정적 함수 나 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()
                }
            }

Swift 3 및 4 :

DispatchQueue에서 확장을 만들고 DispatchQueue asyncAfter 함수를 내부적으로 사용하는 함수 지연을 추가 할 수 있습니다.

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)
        }
    }
}

이제 다음 과 같이 Main 스레드에서 코드를 지연시키기 만하면됩니다 .

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

코드를 다른 스레드 로 지연 시키 려면 다음을 수행 하십시오 .

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

좀 더 편리한 기능도 있는 프레임 워크 를 선호한다면 HandySwift 를 확인 하세요 . Carthage 를 통해 프로젝트에 추가 한 다음 위의 예제와 똑같이 사용할 수 있습니다. 예 :

import HandySwift    

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

이것은 나를 위해 일했습니다.

스위프트 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);
});

I always prefer to use extension instead of free functions.

Swift 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()
    }
  }

}

Use as follow.

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

Delaying GCD call using asyncAfter in swift

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

We can delay as **microseconds,milliseconds,nanoseconds

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

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

In Swift 4

Use this snippet:

    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(), ^{
    // ...
});

The dispatch_after(_:_:_:) function takes three parameters:

a delay
a dispatch queue
a block or closure

The dispatch_after(_:_:_:) function invokes the block or closure on the dispatch queue that is passed to the function after a given delay. Note that the delay is created using the dispatch_time(_:_:) function. Remember this because we also use this function in Swift.

I recommend to go through the tutorial Raywenderlich Dispatch tutorial

use this code to perform some UI related task after 2.0 seconds.

            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 version

Following closure function execute some task after delay on main thread.

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

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

Call this function like:

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

Now more than syntactic sugar for asynchronous dispatches in Grand Central Dispatch (GCD) in Swift.

add Podfile

pod 'AsyncSwift'

Then,you can use it like this.

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 has a pretty short way of doing this:

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

Here is synchronous version of asyncAfter in Swift:

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()

Along with asynchronous one:

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

참고URL : https://stackoverflow.com/questions/24034544/dispatch-after-gcd-in-swift

'program tip' 카테고리의 다른 글

프로그래밍 방식으로 Android API 버전 검색 (0)	2020.10.04
SQL Server : 데이터베이스가 "복원 중"상태로 멈춤 (0)	2020.10.04
Java에서 일반 유형의 인스턴스를 만드시겠습니까? (0)	2020.10.04
대신 아이콘에 태그를 (0)	2020.10.04
Bash 스크립트에서 스크립트 파일 이름을 어떻게 알 수 있습니까? (0)	2020.10.04

현재글dispatch_after-Swift의 GCD?

radiobox

dispatch_after-Swift의 GCD?

dispatch_after-Swift의 GCD?

Swift 3, Xcode 8 Seed 6 업데이트

`NSTimer` vs `dispatch_after`

작업 지연 `NSTimer`

메모

'program tip' 카테고리의 다른 글

'program tip'의 다른글

티스토리툴바

dispatch_after-Swift의 GCD?

dispatch_after-Swift의 GCD?

Swift 3, Xcode 8 Seed 6 업데이트

NSTimer vs dispatch_after

작업 지연 NSTimer

메모

'program tip' 카테고리의 다른 글

'program tip'의 다른글

관련글

티스토리툴바

`NSTimer` vs `dispatch_after`

작업 지연 `NSTimer`