blocks|key|747103|text|希望我能正确理解你的问题，因为你想知道dispatch_async和dispatch_sync之间的区别？|type|unstyled|depth|inlineStyleRanges|entityRanges|data|747104|dispatch_async|code-block|syntax|javascript|747105|将以异步方式将块调度到队列。这意味着在继续执行方法中的其余代码之前，它会将块发送到队列，而不是等待它返回。|747106|dispatch_sync|747107|将同步地将该块分派到队列。这将阻止方法中剩余代码的任何更多执行，直到块完成执行。|747108|我主要使用后台队列的dispatch_async将工作从主队列中转移出来，并利用设备可能具有的任何额外内核。然后，如果我需要更新UI，则使用dispatch_async连接到主线程。|offset|length|style|CODE|747109|祝好运|747110|entityMap^0|0|0|0|0|0|A|E|1Y|E|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@$O|12|P|13|Q|R]|$O|14|P|15|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|6|7|16|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|17|8|@]|9|@]|A|$]]]|V|$]]

Hopefully I'm understanding your question correctly in that you are wondering about the differences between dispatch_async and dispatch_sync?

<pre><code>dispatch_async
</code></pre>

will dispatch the block to a queue asynchronously. Meaning it will send the block to the queue and not wait for it to return before continuing on the execution of the remaining code in your method.

<pre><code>dispatch_sync
</code></pre>

will dispatch the block to a queue synchronously. This will prevent any more execution of remaining code in the method until the block has finished executing.

I've mostly used a <code>dispatch_async</code> to a background queue to get work off the main queue and take advantage of any extra cores that the device may have. Then <code>dispatch_async</code> to the main thread if I need to update the UI.

Good luck

blocks|key|747179|text|它很有用的一个地方是UI活动，比如在冗长的操作之前设置微调器：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|747180|-+(void)+handleDoSomethingButton{

++++[mySpinner+startAnimating];

++++(do+something+lengthy)
++++[mySpinner+stopAnimating];
}|code-block|syntax|javascript|747181|将不会工作，因为您在冗长的代码中阻塞了主线程，而不是让UIKit实际启动微调器。|747182|-+(void)+handleDoSomethingButton{
+++++[mySpinner+startAnimating];

+++++dispatch_async+(dispatch_get_main_queue(),+%5E{
++++++++++(do+something+lengthy)
++++++++++[mySpinner+stopAnimating];
++++});
}|747183|将控制权返回给run循环，该循环将调度UI更新，启动微调器，然后从分派队列中获取下一项内容，即实际处理。处理完成后，将调用动画stop，并返回到run循环，然后使用stop更新UI。|747184|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

One place where it's useful is for UI activities, like setting a spinner before a lengthy operation:

<pre><code>- (void) handleDoSomethingButton{

 [mySpinner startAnimating];

 (do something lengthy)
 [mySpinner stopAnimating];
}
</code></pre>

will not work, because you are blocking the main thread during your lengthy thing and not letting UIKit actually start the spinner. 

<pre><code>- (void) handleDoSomethingButton{
 [mySpinner startAnimating];

 dispatch_async (dispatch_get_main_queue(), ^{
 (do something lengthy)
 [mySpinner stopAnimating];
 });
}
</code></pre>

will return control to the run loop, which will schedule UI updating, starting the spinner, then will get the next thing off the dispatch queue, which is your actual processing. When your processing is done, the animation stop is called, and you return to the run loop, where the UI then gets updated with the stop.

blocks|key|747218|text|Async意味着异步，您应该在大多数时间使用它。你不应该在主线程上调用sync，因为它会锁定你的UI，直到任务完成。以下是在Swift中执行此操作的更好方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|747219|runThisInMainThread+{+()+->+Void+in
++++//+Run+your+code+like+this:
++++self.doStuff()
}

func+runThisInMainThread(block:+dispatch_block_t)+{
++++dispatch_async(dispatch_get_main_queue(),+block)
}|code-block|syntax|javascript|747220|它作为一个标准函数包含在我的存储库中，请查看它：https://github.com/goktugyil/EZSwiftExtensions|offset|length|747221|entityMap|0|LINK|mutability|MUTABLE|url|https://github.com/goktugyil/EZSwiftExtensions^0|0|0|O|1A|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@$I|V|J|W|1|X]]|A|$]]|$1|K|3|-4|5|6|7|Y|8|@]|9|@]|A|$]]]|L|$M|$5|N|O|P|A|$Q|R]]]]

Async means asynchronous and you should use that most of the time. You should never call sync on main thread cause it will lock up your UI until the task is completed. You Here is a better way to do this in Swift:

<pre><code>runThisInMainThread { () -&gt; Void in
 // Run your code like this:
 self.doStuff()
}

func runThisInMainThread(block: dispatch_block_t) {
 dispatch_async(dispatch_get_main_queue(), block)
}
</code></pre>

Its included as a standard function in my repo, check it out: <a href="https://github.com/goktugyil/EZSwiftExtensions" rel="nofollow">https://github.com/goktugyil/EZSwiftExtensions</a>

I have been using with success, grand central dispatch in my apps, but I was wondering what is the real advantage of using something like this:

<pre><code>dispatch_async(dispatch_get_main_queue(), ^{ ... do stuff
</code></pre>

or even

<pre><code>dispatch_sync(dispatch_get_main_queue(), ^{ ... do stuff
</code></pre>

I mean, in both cases you are firing a block to be executed on the main thread, exactly where the app runs and this will not help to reduce the load. In the first case you don't have any control when the block will run. I have seen cases of blocks being executed half a second after you fire them. The second case, it is similar to

<pre><code>[self doStuff];
</code></pre>

right?

I wonder what do you guys think.

iPhone - Grand Central Dispatch main thread

Swift

我已经在我的应用程序中成功地使用了grand中央调度，但我想知道使用这样的东西的真正优势是什么：dispatch_async(dispatch_get_main_queue(), ^{ ... do stuff甚至是dispatch_sync(dispatch_get_main_queue(), ^{ ... do s...

问iPhone -中央调度主线程
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问iPhone -中央调度主线程EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问iPhone -中央调度主线程
EN