iBookを使用しました Apple定義を見つけることができませんでした。
誰かが構造を説明できますかdispatch_after
?
dispatch_after(<#when: dispatch_time_t#>, <#queue: dispatch_queue_t?#>, <#block: dispatch_block_t?#>)
iBookを使用しました Apple定義を見つけることができませんでした。
誰かが構造を説明できますか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(1, dispatch_get_main_queue()) { println("test") }
1
中をdispatch_after(1, ...
、ここで多くの混乱を引き起こす可能性があります。人々は、それが実際にはナノ秒であるとき、それが秒数であると考えるでしょう。この番号を正しく作成する方法については@brindyの回答を参照することをお勧めします。
1
してくださいdispatch_time(DISPATCH_TIME_NOW, Int64(1 * Double(NSEC_PER_SEC)))
。人々は、Swiftでdispatch_time_tを作成する必要がないと考えるかもしれません
Binary operator '+' cannot be applied to operands of type DispatchTime and '_'
ライン上でlet delayTime = DispatchTime.now() + .seconds(1.0)
DispatchTime.now() + 1.0
それを機能させる唯一の方法のように書き換える(は必要ありません.seconds
)
私は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
}
うわー、あなたは言語を改善することができる言語です。何が良いでしょうか?
呼び出し構文を改善したので、ほとんど気にする必要がないようです:
func delay(_ delay:Double, closure:@escaping ()->()) {
let when = DispatchTime.now() + delay
DispatchQueue.main.asyncAfter(deadline: when, execute: closure)
}
func delayInSec(delay: Double) -> dispatch_time_t { return dispatch_time(DISPATCH_TIME_NOW, Int64(delay * Double(NSEC_PER_SEC))) }
return
ます。
1.0 ~~ { code...}
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にキャストしない場合、暗黙のタイピングによりコンパイルエラーが発生します。
誰かがより最適な解決策を提案できるなら、私はそれを聞きたいと思っています。
dispatch_get_current_queue()
。dispatch_get_main_queue()
代わりに使用しました。
dispatch_get_main_queue()
間違いなくあなたが使用すべきものです。更新されます。
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コード
performSelector:afterDelay:
はSwift 2で使用できるようになりました。キャンセルできます。
dispatch_source_t
これはキャンセルできるため、を使用します)。
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")
})
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
}
}
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
。キャンセルする必要がないワンタイムイベントがある場合は、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()
}
}
これでうまくいきました。
スウィフト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);
});
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)
}
}
}
次のように、メインスレッドでコードを遅延させるだけです。
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
}
私は常に無料の関数の代わりに拡張機能を使うことを好みます。
スウィフト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
}
迅速に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())
}
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チュートリアルに進むことをお勧めします
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!
}
このコードを使用して、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)の非同期ディスパッチの構文シュガー以上のものになりました。
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")
}
Swift 4には、これを行うためのかなり短い方法があります。
Timer.scheduledTimer(withTimeInterval: 2, repeats: false) { (timer) in
// Your stuff here
print("hello")
}
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()))
}