blocks|key|536002|text|当您使用同步时，它会在队列的线程中执行，但是同步在完成之前不会返回。异步立即返回。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|536003|因为您有一个串行队列，所以打印结果是相同的，但是调用函数可以在队列完成打印之前返回。如果是同步的，则调用函数将等待打印完成。|536004|Swift中还没有异步/等待概念。这不是这里正在发生的事情(或者在同步情况下)。|536005|如果要查看差异，请将睡眠放在块中，并在队列调用之外打印。|536006|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|L|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|M|8|@]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

When you use sync, it executes in the queue’s thread, but sync doesn’t return until it is done. async returns immediately. 

Because you have a serial queue, the prints are the same, but the calling function can return before the queue has done the printing. If it were sync, the calling function would be waiting for the prints to finish. 

There is no async/await concept in Swift yet. That is not what is happening here (or in the sync case)

If you want to see the difference, put sleeps in the blocks and prints outside the queue calls.

blocks|key|31554|text|由于对这两种工作都使用相同的队列，第二个异步块在第一个块结束之前不会开始执行。它是异步的还是串行的并不重要。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|31555|如果在两个队列之间添加一个print语句，您将看到.async和.sync之间的真正区别。如下所示：|offset|length|style|CODE|31556|queue.async+{
++++for+_+in+1...100+{
++++++++++self.smile()
++++}
}
print("Finished+printing+smiles")
queue.async+{
++++for+_+in+1...100+{
++++++++++self.love()
++++}
}|code-block|syntax|javascript|31557|之前的代码可能会打印“完成打印微笑”，甚至在它已经开始打印微笑！这是因为异步工作立即返回并继续执行代码。|31558|让我们看看如果用同步队列更改队列会发生什么：|31559|queue.sync+{
++++for+_+in+1...100+{
++++++++++self.smile()
++++}
}
print("Finished+printing+smiles")
queue.sync+{
++++for+_+in+1...100+{
++++++++++self.love()
++++}
}|31560|是啊。现在，同步队列在结束之前等待，然后再继续。所以，你会得到100个微笑，然后“完成打印微笑”。|31561|如果您想实现并发，即同时执行两个代码块(但不是同时执行，因为这是并行的)，则必须使用两个不同的队列，或者在队列配置中指定.concurrent参数：|31562|override+func+viewDidLoad()+{

++++let+queue+=+DispatchQueue(label:+"SerialQueue")
++++let+queue2+=+DispatchQueue(label:+"AnotherQueue")

++++queue.async+{
++++++++for+_+in+1...100+{
++++++++++++++self.smile()
++++++++}
++++}
++++print("Finished+printing+smiles")
++++queue2.async+{
++++++++for+_+in+1...100+{
++++++++++++++self.love()
++++++++}
++++}
}|31563|正如您所看到的，这里的顺序是混乱的，并且在执行过程中会有所不同。这是因为两个队列同时运行。|31564|另一个等同于这一代码的是：|31565|let+queue+=+DispatchQueue(label:+"ConcurrentQueue",+attributes:+.concurrent)

queue.async+{
++++for+_+in+1...100+{
++++++++++self.smile()
++++}
}
print("Finished+printing+smiles")
queue.async+{
++++for+_+in+1...100+{
++++++++++self.love()
++++}
}|31566|entityMap^0|0|P|6|W|5|0|0|0|0|0|0|1O|B|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|16|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|17|8|@$D|18|E|19|F|G]|$D|1A|E|1B|F|G]]|9|@]|A|$]]|$1|H|3|I|5|J|7|1C|8|@]|9|@]|A|$K|L]]|$1|M|3|N|5|6|7|1D|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1E|8|@]|9|@]|A|$]]|$1|Q|3|R|5|J|7|1F|8|@]|9|@]|A|$K|L]]|$1|S|3|T|5|6|7|1G|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1H|8|@$D|1I|E|1J|F|G]]|9|@]|A|$]]|$1|W|3|X|5|J|7|1K|8|@]|9|@]|A|$K|L]]|$1|Y|3|Z|5|6|7|1L|8|@]|9|@]|A|$]]|$1|10|3|11|5|6|7|1M|8|@]|9|@]|A|$]]|$1|12|3|13|5|J|7|1N|8|@]|9|@]|A|$K|L]]|$1|14|3|-4|5|6|7|1O|8|@]|9|@]|A|$]]]|15|$]]

Since you're using the same queue for both works, the second async block won't start executing until the first block ends. It doesn't matter if it's asynchronous or serial.

You'll see the true difference between <code>.async</code> and <code>.sync</code> if you add a print statement between both queues. Like this:

<pre class="lang-swift prettyprint-override"><code>queue.async {
 for _ in 1...100 {
 self.smile()
 }
}
print("Finished printing smiles")
queue.async {
 for _ in 1...100 {
 self.love()
 }
}
</code></pre>

The previous code will probably print "Finished printing smiles" even before it has started printing smiles! That's because async work returns instantly and keeps executing code.

<hr>

And let's see what happens if you change the queues with synchronous queues:

<pre class="lang-swift prettyprint-override"><code>queue.sync {
 for _ in 1...100 {
 self.smile()
 }
}
print("Finished printing smiles")
queue.sync {
 for _ in 1...100 {
 self.love()
 }
}
</code></pre>

Yup. Now the sync queue waits before the closure completes before carrying on. So, you'll get 100 smiles, and then the "Finished printing smiles".

<hr>

If you want to achieve concurrency, that's it, two blocks of code executing simultaneously (but not at exactly the same time, because that would be parallelism), you'll have to use two different queues, or specify the <code>.concurrent</code> parameter in the queue configuration:

<pre class="lang-swift prettyprint-override"><code>override func viewDidLoad() {

 let queue = DispatchQueue(label: "SerialQueue")
 let queue2 = DispatchQueue(label: "AnotherQueue")

 queue.async {
 for _ in 1...100 {
 self.smile()
 }
 }
 print("Finished printing smiles")
 queue2.async {
 for _ in 1...100 {
 self.love()
 }
 }
}
</code></pre>

As you'll see, the order here is chaotic and will vary between executions. That's because both queues are running at the same time.

Another equivalent to this code would be:

<pre class="lang-swift prettyprint-override"><code>let queue = DispatchQueue(label: "ConcurrentQueue", attributes: .concurrent)

queue.async {
 for _ in 1...100 {
 self.smile()
 }
}
print("Finished printing smiles")
queue.async {
 for _ in 1...100 {
 self.love()
 }
}
</code></pre>

blocks|key|1919858|text|卢弗兰科和罗伯托已经详细地回答了问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1919859|您还可以在单个OperationQueue上实现这一点，在其上添加不同的BlockOperation。|offset|length|style|CODE|1919860|就好像您会在这个场景中看到：|1919861|let+queue+=+OperationQueue()

let+operation1+=+BlockOperation+{
++++for+_+in+1...5+{
+++++smile()
++}
}
print("Done")
let+operation2+=+BlockOperation+{
++++for+_+in+1...5+{
+++++love()
+++}
+}

queue.addOperation+(operation1)
queue.addOperation+(operation2)|code-block|syntax|javascript|1919862|产出如下：|1919863|​|1919864|📷|atomic|1919865|1919866|如果要添加operation2依赖于operation1：|1919867|operation2.addDependency(operation1)
queue.addOperation+(operation1)
queue.addOperation+(operation1)|1919868|1919869|1919870|1919871|1919872|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://developer.qcloudimg.com/http-save/yehe-900000/d9471ec59272cfbfbeb0bfa440467fff.png|imageAlt|1|https://developer.qcloudimg.com/http-save/yehe-900000/596a5f561bcfc02a8972945e203cf525.png^0|0|7|E|10|E|0|0|0|0|0|0|1|0|0|0|0|0|0|0|0|1|1|0|0^^$0|@$1|2|3|4|5|6|7|1F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1G|8|@$D|1H|E|1I|F|G]|$D|1J|E|1K|F|G]]|9|@]|A|$]]|$1|H|3|I|5|6|7|1L|8|@]|9|@]|A|$]]|$1|J|3|K|5|L|7|1M|8|@]|9|@]|A|$M|N]]|$1|O|3|P|5|6|7|1N|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1O|8|@]|9|@]|A|$]]|$1|S|3|T|5|U|7|1P|8|@]|9|@$D|1Q|E|1R|1|1S]]|A|$]]|$1|V|3|R|5|6|7|1T|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|1U|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|L|7|1V|8|@]|9|@]|A|$M|N]]|$1|10|3|P|5|6|7|1W|8|@]|9|@]|A|$]]|$1|11|3|R|5|6|7|1X|8|@]|9|@]|A|$]]|$1|12|3|T|5|U|7|1Y|8|@]|9|@$D|1Z|E|20|1|21]]|A|$]]|$1|13|3|R|5|6|7|22|8|@]|9|@]|A|$]]|$1|14|3|-4|5|6|7|23|8|@]|9|@]|A|$]]]|15|$16|$5|17|18|19|A|$1A|1B|1C|-4]]|1D|$5|17|18|19|A|$1A|1E|1C|-4]]]]

@loufranco and @Roberto has answered in detailed way.

You can also achieve this on a single <code>OperationQueue</code> adding different <code>BlockOperation</code> on it.

As if you will see in this scenario:

<pre><code>let queue = OperationQueue()

let operation1 = BlockOperation {
 for _ in 1...5 {
 smile()
 }
}
print("Done")
let operation2 = BlockOperation {
 for _ in 1...5 {
 love()
 }
 }

queue.addOperation (operation1)
queue.addOperation (operation2)
</code></pre>

The output is :

<a href="https://i.stack.imgur.com/PSpTl.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/PSpTl.png" alt="enter image description here"></a>

And if you will add operation2 dependency on operation1:

<pre><code>operation2.addDependency(operation1)
queue.addOperation (operation1)
queue.addOperation (operation1)
</code></pre>

The Output is :

<a href="https://i.stack.imgur.com/M6CeL.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/M6CeL.png" alt="enter image description here"></a>

I have some idea about JS and was going through iOS 

I was reading <a href="https://medium.com/swift-india/a-complete-anatomy-of-dispatch-queue-in-swift-fa30c7628132" rel="nofollow noreferrer">this blog</a> and am confused about async and sync in Swift (although I have a feeling that it's same in IOS and Javascript) but anyway 

<pre><code>import UIKit 

func smile () {
 print('1')
}

func love() {
 print('2')
}

//Serial Queue

let queue = DispatchQueue(label: 'SerialQueue')

queue.async {
 for _ in 1...5 {
 smile()
 }
}

 queue.async {
 for _ in 1...5 {
 love()
 }
 }
</code></pre>

This would log something like this 
1

<pre><code>1
1
1
1
2
2
2
2
2
</code></pre>

Thinking about the example, If it was a sync instead of async then the output would've been the same? so what's the use of using async above? 

Also, In JS we need to await. In swift we don't have to do anything? Can someone explain it to me by giving example of async and await in swift?

Sync vs Async Queue in iOS

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我对JS有一些了解，我正在浏览iOS我当时正在读，我对Swift中的异步和同步感到困惑(尽管我觉得IOS和Javascript中的异步和同步是一样的)，但无论如何import UIKit func smile () {    print('1')}func love() {    print('2')}//Serial...

问在iOS中同步与异步队列
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在iOS中同步与异步队列EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问在iOS中同步与异步队列
EN