dispatch_after-SwiftのGCD?


558

iBookを使用しました Apple定義を見つけることができませんでした。

誰かが構造を説明できますかdispatch_after

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

1
Appleはこの本を2018年に出版しませんでした。最新のアーカイブは2017年12月のものです。iBookへの古いリンクは、単純にdeveloper.apple.com/documentation/swiftにリダイレクトさます。
・クール

回答:


742

構造のより明確なアイデア:

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

dispatch_time_tですUInt64dispatch_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数値を書き込むだけの場合、秒を使用していると見なされます。


17
ヒント:ブロックが最後のパラメータは、関数にあるので、あなたは余分な読みやすさのためスウィフトの「後閉鎖」構文を使用することができますdispatch_after(1, dispatch_get_main_queue()) { println("test") }
ビル

8
私は、数の使用を考える1中をdispatch_after(1, ...、ここで多くの混乱を引き起こす可能性があります。人々は、それが実際にはナノ秒であるとき、それが秒数であると考えるでしょう。この番号を正しく作成する方法については@brindyの回答を参照することをお勧めします。
Hlung 2014

3
混乱を招きますのでに変更1してくださいdispatch_time(DISPATCH_TIME_NOW, Int64(1 * Double(NSEC_PER_SEC)))。人々は、Swiftでdispatch_time_tを作成する必要がないと考えるかもしれません
OemerA

4
Swift 3バージョンが機能していないようです。また苦情そのBinary operator '+' cannot be applied to operands of type DispatchTime and '_'ライン上でlet delayTime = DispatchTime.now() + .seconds(1.0)
アンディ・アイバニーズ

9
DispatchTime.now() + 1.0それを機能させる唯一の方法のように書き換える(は必要ありません.seconds
Andy Ibanez

1093

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

2
私はちょうどになってしまった、遅延計算のためのショートカットを必要:func delayInSec(delay: Double) -> dispatch_time_t { return dispatch_time(DISPATCH_TIME_NOW, Int64(delay * Double(NSEC_PER_SEC))) }
Avielグロス

4
@ agf119105クロージャにコードが1行しかない場合は、別のコード行(例:)を追加しreturnます。
マット2014年

2
@GastonM無関係です。関数を渡すこと自体には、メモリ管理の問題はありません。
マット

7
「あなたが言語を改善できる言語」。グローバル関数を定義することで言語がどのように改善されるのか、あるいはCでもこれができない理由がわかりません。多分あなたが演算子をオーバーロードした場合;)1.0 ~~ { code...}
Yerk

8
あなたの答えの正しさを問うのではなく、「私はdispatch_afterをあまり頻繁に使用する」のではなく、便利な関数を提供しないことで対処するのが最もよいコードの匂いではありませんか?
Nikolai Ruhe

128

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にキャストしない場合、暗黙のタイピングによりコンパイルエラーが発生します。

誰かがより最適な解決策を提案できるなら、私はそれを聞きたいと思っています。


で非推奨のAPIのコンパイラエラーが発生しますdispatch_get_current_queue()dispatch_get_main_queue()代わりに使用しました。
David L

@DavidL-ありがとう、dispatch_get_main_queue()間違いなくあなたが使用すべきものです。更新されます。
ブリンディ2014

私は、迅速な3と遊び場でこれを試してみましたが、それは動作しません
μολὼν.λαβέ

@GAlexanderは私のために働く。プレイグラウンドを無期限に実行することを許可していますか?
ブリンディ16

ええと、いやいや、数時間実行しても、何も印刷されませんでした。これが私が使ったものです。"インポートディスパッチインポートダーウィンインポートCoreGraphics「DispatchQueue.main.asyncAfter(期限.now()+ 4.5){プリント("ここに来た")}"
μολὼν.λαβέ

83

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コード


1
performSelector:afterDelayのパフォーマンス機能の1つは、それをキャンセルする機能です。このソリューションだけが問題をカバーします。ありがとう
HotJard

@HotJardこれperformSelector:afterDelay:はSwift 2で使用できるようになりました。キャンセルできます。
マット2015年

@mattですが、NSObjectでのみ使用できますね。
HotJard

@HotJardもちろんですが、まったくないよりはましです。そこに問題はありません。ただし、この回答と同じように、GCDベースのキャンセル可能なタイマーを作成することでその損失をすでに埋め合わせていました(dispatch_source_tこれはキャンセルできるため、を使用します)。
マット

2
どうもありがとう、私はこれをSwift 2.3まで使用してきました。Swift 3.0コンパイラーは現在不満を言っています。答えを更新していただければ幸いです。
非自動

27

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
}

22

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

14

別の方法は、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)
    })

私はマットの遅延機能が好きですが、好みに反して、クロージャーの受け渡しを制限したいと思います。


8

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

4

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

4

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

3

OPによる元の質問ではありませんが、特定のNSTimer関連する質問はこの質問の重複としてマークされているため、NSTimerここに回答を含める価値があります。

NSTimerdispatch_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) 
  • ここで私の完全な答えを参照してください。


3

複数の関数にはこれを使用します。これは、静的関数や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()
                }
            }

2

これでうまくいきました。

スウィフト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)")
}

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

2

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

1

使用率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をチェックアウトしてくださいCarthage介してプロジェクトに追加し、上記の例とまったく同じように使用できます。例:

import HandySwift    

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

1

私は常に無料の関数の代わりに拡張機能を使うことを好みます。

スウィフト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
}

1

迅速に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())
}

1

ではスウィフト4

このスニペットを使用してください:

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

これはすでに他の回答(ブリンディーズ、またはラフルズなど)にあります...同じ構文...
Eric Aya

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

このdispatch_after(_:_:_:)関数は3つのパラメーターを取ります。

ブロックまたはクロージャの
ディスパッチキューの遅延

dispatch_after(_:_:_:)関数は、指定された遅延時間後に関数に渡されるディスパッチキュー上のブロックまたは閉鎖を起動します。dispatch_time(_:_:)関数を使用して遅延が作成されることに注意してください。Swiftでもこの関数を使用しているため、これを覚えておいてください。

チュートリアルRaywenderlich Dispatchチュートリアルに進むことをお勧めします


1

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

0

このコードを使用して、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")
}

1
これは以前の回答とほぼ同じです
Daniel Galasko

...この答えは、初期の2016年に行われたようだと、少なくとも他の6件の回答よりも古いです
eharo2

0

これで、SwiftのGrand Central Dispatch(GCD)の非同期ディスパッチの構文シュガー以上のものになりました。

Podfileを追加する

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

Appleは、GCDを使用するために必要なすべてを数行で提供してくれました。ポッドやワークスペースなどに煩わされるのはなぜですか?@エスケープとキャプチャに関するドキュメントを読んでください。それで十分です。
ingconti

0

Swift 4には、これを行うためのかなり短い方法があります。

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

0

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

非同期のものと一緒に:

let deadline = DispatchTime.now() + .seconds(3)
DispatchQueue.main.asyncAfter(deadline: deadline) {
    dispatchPrecondition(condition: .onQueue(DispatchQueue.global()))
}
弊社のサイトを使用することにより、あなたは弊社のクッキーポリシーおよびプライバシーポリシーを読み、理解したものとみなされます。
Licensed under cc by-sa 3.0 with attribution required.