热门标签 | HotTags
当前位置:  开发笔记 > 编程语言 > 正文

开发笔记:Swift并发编程的10大陷阱

篇首语:本文由编程笔记#小编为大家整理,主要介绍了Swift并发编程的10大陷阱相关的知识,希望对你有一定的参考价值。

篇首语:本文由编程笔记#小编为大家整理,主要介绍了Swift并发编程的10大陷阱相关的知识,希望对你有一定的参考价值。






作者|Jan Olbrich


译者|无明


编辑|覃云

在使用 Swift 进行并发编程时,操作系统提供了一些底层的基本操作。例如,苹果为此提供了框架或其他东西,比如已经在 Javascript 中广泛使用的 promise。这篇文章将对 Swift 的并发编程做更加全面的介绍,并告诉大家,如果不了解并发,有可能会犯下哪些错误。



原子性

Swift 中的原子性与数据库中的事务具有相同的概念,即一次性写入一个值被视为一个操作。在将应用程序编译为 32 位时,如果没有使用原子性,并在代码中使用了 int64_t,那么可能会出现相当奇怪的行为。为什么?让我们来详细了解下:

int64_t x = 0
Thread1:
x = 0xFFFF
Thread2:
x = 0xEEDD

第一个线程开始往 x 写入值,但由于应用程序需要运行在 32 位操作系统上,我们必须将要写入 x 的值分成两批 0xFF。

当 Thread2 尝试同时写入 x 时,可能会按以下顺序执行:

Thread1: part1
Thread2: part1
Thread2: part2
Thread1: part2

最后我们会得到:

x == 0xEEFF

既不是 0xFFFF 也不是 0xEEDD。

如果使用原子性,我们就创建了一个单独的事务,于是就变成:

Thread1: part1
Thread1: part2
Thread2: part1
Thread2: part2

结果,x 包含 Thread2 设置的值。Swift 本身没有提供原子性实现,不过已经有建议要在 Swift 中添加原子性,但目前,你必须自己实现它。

最近,我修复了一个 bug,这个 bug 是由两个不同线程同时向一个数组写入引起的。如果同一组中的两个操作可以并行运行并且同时失败,会发生什么?它们将尝试同时向错误数组写入,这将导致 Swift.Array 的“allocate capacity”错误。要修复这个问题,数组必须是线程安全的,可以使用同步数组。

一般情况下,在每次写入时必须进行加锁。

但需要注意的是,读取也可能失败:

var messages: [Message] = []
func dispatch(_ message: Message) {
 messages.append(message)
 dispatchToPlugins()
}
func dispatchToPlugins() {
 while messages.count > 0 {
   for plugin in plugins {
     plugin.dispatch(message: messages[0])
   }
   messages.remove(at:0)
 }
}
Thread1:
dispatch(message1)
Thread2:
dispatch(message2)

我们循环遍历一个数组,只要数组长度不为 0,就将数组中的元素分派给插件,然后从数组中移除。这种方式非常容易导致“index out of range”异常。



内存屏障

现在的 CPU 有多个内核,并包含了智能编译器,我们无法预测代码会运行在哪个内核上。硬件甚至会优化我们的内存操作。簿记(bookkeeping)可确保它们在同一个内核上是按照一定的顺序执行的。遗憾的是,这仍然可能导致一个内核会看到不同顺序的内存变更。看看这个简单的例子:

//Processor #1:
while f == 0 {
 print x
}
//Processor #2:
x = 42
f = 1

你可能希望这段代码会打印出 42,因为 x 是在 f 被设置为 false 之前赋值的。不过有时可能发生这种情况,即第二个 CPU 以相反的顺序看到内存的变更,因此会先结束循环,打印 x 的值,然后才看到新值 42。

我还没有在 ios 上看到过这种情况,但这并不意味着它不会发生。特别随着 CPU 内核数量越来越多,对这种底层硬件陷阱的认识至关重要。

那么该如何解决这个问题?Apple 为此提供了内存屏障。它们是一组命令,用于确保在执行下一个内存操作之前完成当前的操作。这将阻止 CPU 优化我们的代码,导致执行时间变慢一些。但你没有必要太注意这点性能差异,除非你是在构建高性能的系统。

内存屏障使用起来很简单,但要注意,它是一个操作系统函数,不属于 Swift。因此 API 是使用 C 语言实现的。

OSMemoryBarrier() // from

在上面的代码中使用内存屏障:

//Processor #1:
while f == 0 {
 OSMemoryBarrier()
 print x
}
//Processor #2:
x = 42
OSMemoryBarrier()
f = 1

这样,我们所有的内存操作都将按顺序进行,不必担心硬件内存重新排序会产生不必要的副作用。



竟态条件

发生竞态条件时,多个线程的行为取决于单个线程的运行时行为。假设有两个线程,一个执行计算并将结果保存在 x 中,另一个(可能来自不同的线程,比如用户交互线程)将结果打印到屏幕上:

var x = 100
func calculate() {
   var y = 0
   for i in 1...1000 {
       y += i
   }
   x = y
}
calculate()
print(x)

根据这些线程执行的时间点,Thread2 有可能不会将计算结果打印到屏幕上,它可能还持有之前的值,而这样的行为是非预期的。

还有另外一种情况,即两个线程向同一个数组写入。假设第一个线程将“Concurrency with Swift:”中的单词写入数组,另一个线程写入“What could possibly go wrong?”。我们可以这样实现:

func write(_ text: String) {
   let words = text.split(separator: " ")
   for word in words {
       title.append(String(word))
   }
}
write("Concurrency with Swift:") // Thread 1
write("What could possibly go wrong?") // Thread 2

我们可能会得到错乱的标题:

“Concurrency with What could possibly Swift: go wrong?”

这不是我们所期望的那样,不是吗?不过我们有很多种方法可以解决这个问题:

var title : [String] = []
var lock = NSLock()
func write(_ text: String) {
   let words = text.split(separator: " ")
   lock.lock()
   for word in words {
       title.append(String(word))
       print(word)
   }
   lock.unlock()

另一种方法是使用 Dispatch Queue:

var title : [String] = []
func write(_ text: String) {
   let words = text.split(separator: " ")
   DispatchQueue.main.async {
       for word in words {
           title.append(String(word))
           print(word)
       }
   }

可以根据你的需求选择其中的一种。一般来说,我倾向于使用 Dispatch Queue。这种方法可以防止出现死锁等问题,我们将在下面详细介绍。



死锁

我们可以使用多种方法来解决竟态条件问题,但如果我们使用了 Lock、Mutexe 或 Semaphore,将会引入另一个问题:死锁。

死锁是由环状等待引起的。一个线程在等待第二个线程持有的资源,第二个线程也在等待第一个线程持有的资源。

Swift并发编程的10大陷阱

举个简单的例子,在一个银行账户上执行一个事务,这个事务分为两个部分:先取款,后存款。

代码看起来像这样:

class Account: NSObject {
   var balance: Double
   var id: Int
   override init(id: Int, balance: Double) {
       self.id = id
       self.balance = balance
   }
   func withdraw(amount: Double) {
       balance -= amount
   }
   func deposit(amount: Double) {
       balance += amount
   }
}
let a = Account(id: 1, balance: 1000)
let b = Account(id: 2, balance: 300)
DispatchQueue.global(qos: .background).async {
   transfer(from: a, to: b, amount: 200)
}
DispatchQueue.global(qos: .background).async {
   transfer(from: b, to: a, amount: 200)
}
func transfer(from: Account, to: Account, amount: Double) {
   from.synchronized(lockObj: self) { () -> T in
       to.synchronized(lockObj: self) { () -> T in
           from.withdraw(amount: amount)
           to.deposit(amount: amount)
       }
   }
}
extension NSObject {
   func synchronized(lockObj: AnyObject!, closure: () throws -> T) rethrows ->  T
   {
       objc_sync_enter(lockObj)
       defer {
           objc_sync_exit(lockObj)
       }
       return try closure()
   }
}

我们在事务之间引入了依赖关系,这将导致死锁。

另一个死锁问题是哲学家就餐问题。在维基百科上是这么描述的:



“五位沉默的哲学家坐在圆桌旁,桌上放着一碗意大利面。叉子放置在每对相邻的哲学家之间。


每位哲学家都必须在思考和吃饭之间交替。不过,哲学家只有在左手边和右手边的叉子同时可用时才能吃意大利面。每个叉子同时只能由一位哲学家持有,因此只有当没有其他哲学家在使用它时,其中的一位哲学家才能使用它。一位哲学家在吃完之后,需要放下两把叉子,以便让其他哲学家使用叉子。哲学家可以拿起他右手边或左手边的叉子,但是在拿到两个叉子之前不能开始进食。


进食不受意大利面条或胃的限制,假设面条可以无限量供应,哲学家的胃也是填不饱的。”



你可以花很多时间来解决这个问题,这里有一个简单的方法,例如:

1 . 抓住你左边的叉子,如果有的话

2 . 等待右边的叉子

2a. 如果它可用:拿起它

2B. 如果经过一段时间后,没有叉子可用,把左边的叉子放回原处

3 . 退后并重新开始

这种方式可能不起作用,实际上很有可能会引起死锁。



活锁

活锁(livelock)是死锁的一个特例。死锁是指等待一个资源被释放,而活锁是指多个线程等待其他线程释放资源。这些资源不断改变状态,但这些切来切去的线程却毫无进展。

在现实生活中,活锁可以发生在一个狭小的巷子里,两个人都想要穿过去,但出于礼貌,他们走在了同一边。然后他们尝试同时切换到了另一边,结果又把彼此挡住了。这可以无限期地发生下去,从而产生活锁。你之前可能经历过这个。



严重争用锁

锁可能导致的另一个问题是严重争用锁(Heavily Contended Lock)。想象一下收费站,如果汽车到达收费站速度比收费站的处理速度快,就会发生堵车。锁和线程也是如此。如果一个锁被严重争用,那么同步部分就执行缓慢。这将导致很多线程排队,被挂起,最终会影响性能。



线程饥饿

如前所述,线程可以有不同的优先级。线程优先级可以让我们确保特定任务将尽快得到执行。但是,如果我们将少量任务添加到低优先级线程中,而将大量任务添加到高优先级线程中,会发生什么?低优先级线程将会出现饥饿,因为它将得不到执行时间。结果是,低优先级的任务将不会被执行或需要很长时间才能执行完。



优先级倒置

一旦我们加入锁机制,上面的线程饥饿就会变得很有趣。现在假设有一个低优先级的线程 3,它锁定了一个资源。高优先级线程 1 想要访问此资源,因此必须等待。另一个优先级高于 3 的线程 2 将会带来灾难性的结果。因为它的优先级高于线程 3,它将首先被执行。如果这个线程长时间运行,它将占用线程 3 可以使用的所有资源。由于线程 3 无法执行,导致线程 1 阻塞,所以线程 2 成了饿死线程 1 的“凶手”。即使线程 1 的优先级高于线程 2,情况也是如此。



太多线程

说了这么多与线程有关的内容,还有最后一点需要提及。你可能不会遇到这种情况,但它仍然可能发生。线程的状态改变其实是上下文切换。作为开发人员,我们经常抱怨在多任务间切换(或被人打断)会让我们效率低下。如果进行上下文切换,CPU 也会发生同样的情况。所有预加载的命令都需要刷新,而且在短时间内它无法进行任何命令预测。

那么如果我们经常切换线程会发生什么呢?CPU 将无法再预测任何内容,从而导致效率低下。它只能执行当前命令,并且必须等待下一个,这会导致更多的开销。

作为一般性准则,尽量不要使用太多线程:

“尽可能少,够用就好。”



Swift 警告

即使你正确地完成了所有操作,可以完全控制好同步、锁定、内存操作和线程,但仍然有一点需要注意。Swift 编译器不保证会保留你的代码的执行顺序,这可能导致你的同步机制不会与你编写它们时的顺序保持一致。

换一种说法:

“Swift 本身并不是 100%线程安全的”。

如果你想要对并发性(例如在使用 AudioUnits 时)做出 100% 的保证,可能需要回到 Objective-C。



  结 论  

如你所见,并发是个复杂的话题。很多情况下都会出错,但同时又给我们带来好处。我们使用的大多数工具都是面向开发人员的,如果代码太多,将无法进行调试。所以,谨慎选择你的工具。

苹果提供了一些调试并发性的工具,例如 Activity Group 和 Breadcrumb。可惜的是,它们目前在 Swift 中不受支持(尽管有一个包装器可用在 Activity 上)。



 
英文原文

https://medium.com/flawless-app-stories/parallel-programming-with-swift-what-could-possibly-go-wrong-f5bcc38b1814



 
课程推荐

2018 世界杯总决赛巅峰对决在即,《技术领导力 300 讲专栏》超级团燃情上线。

池建强、冯大辉、左耳朵耗子、tinyfool 四位技术大佬轮番上阵,领衔开团,邀你一起拼,让强者更强。


推荐阅读
  • 本指南从零开始介绍Scala编程语言的基础知识,重点讲解了Scala解释器REPL(读取-求值-打印-循环)的使用方法。REPL是Scala开发中的重要工具,能够帮助初学者快速理解和实践Scala的基本语法和特性。通过详细的示例和练习,读者将能够熟练掌握Scala的基础概念和编程技巧。 ... [详细]
  • 本文深入解析了Java面向对象编程的核心概念及其应用,重点探讨了面向对象的三大特性:封装、继承和多态。封装确保了数据的安全性和代码的可维护性;继承支持代码的重用和扩展;多态则增强了程序的灵活性和可扩展性。通过具体示例,文章详细阐述了这些特性在实际开发中的应用和优势。 ... [详细]
  • 本文探讨了 Java 中 Pair 类的历史与现状。虽然 Java 标准库中没有内置的 Pair 类,但社区和第三方库提供了多种实现方式,如 Apache Commons 的 Pair 类和 JavaFX 的 javafx.util.Pair 类。这些实现为需要处理成对数据的开发者提供了便利。此外,文章还讨论了为何标准库未包含 Pair 类的原因,以及在现代 Java 开发中使用 Pair 类的最佳实践。 ... [详细]
  • Spring框架的核心组件与架构解析 ... [详细]
  • 在本节课程中,我们将深入探讨 JSP 编程中的实际案例,通过具体代码示例 `code316.java` 来解析数据库连接的实现。该示例展示了如何使用 Java 的 JDBC API 进行数据库操作,包括加载数据库驱动、建立连接等关键步骤。通过本课程的学习,读者将能够更好地理解和应用 JSP 中的数据库连接技术。 ... [详细]
  • 如何利用Java 5 Executor框架高效构建和管理线程池
    Java 5 引入了 Executor 框架,为开发人员提供了一种高效管理和构建线程池的方法。该框架通过将任务提交与任务执行分离,简化了多线程编程的复杂性。利用 Executor 框架,开发人员可以更灵活地控制线程的创建、分配和管理,从而提高服务器端应用的性能和响应能力。此外,该框架还提供了多种线程池实现,如固定线程池、缓存线程池和单线程池,以适应不同的应用场景和需求。 ... [详细]
  • 第六章:枚举类型与switch结构的应用分析
    第六章深入探讨了枚举类型与 `switch` 结构在编程中的应用。枚举类型(`enum`)是一种将一组相关常量组织在一起的数据类型,广泛存在于多种编程语言中。例如,在 Cocoa 框架中,处理文本对齐时常用 `NSTextAlignment` 枚举来表示不同的对齐方式。通过结合 `switch` 结构,可以更清晰、高效地实现基于枚举值的逻辑分支,提高代码的可读性和维护性。 ... [详细]
  • 本文总结了JavaScript的核心知识点和实用技巧,涵盖了变量声明、DOM操作、事件处理等重要方面。例如,通过`event.srcElement`获取触发事件的元素,并使用`alert`显示其HTML结构;利用`innerText`和`innerHTML`属性分别设置和获取文本内容及HTML内容。此外,还介绍了如何在表单中动态生成和操作``元素,以便更好地处理用户输入。这些技巧对于提升前端开发效率和代码质量具有重要意义。 ... [详细]
  • 本文深入解析了Java 8并发编程中的`AtomicInteger`类,详细探讨了其源码实现和应用场景。`AtomicInteger`通过硬件级别的原子操作,确保了整型变量在多线程环境下的安全性和高效性,避免了传统加锁方式带来的性能开销。文章不仅剖析了`AtomicInteger`的内部机制,还结合实际案例展示了其在并发编程中的优势和使用技巧。 ... [详细]
  • AIX编程挑战赛:AIX正方形问题的算法解析与Java代码实现
    在昨晚的阅读中,我注意到了CSDN博主西部阿呆-小草屋发表的一篇文章《AIX程序设计大赛——AIX正方形问题》。该文详细阐述了AIX正方形问题的背景,并提供了一种基于Java语言的解决方案。本文将深入解析这一算法的核心思想,并展示具体的Java代码实现,旨在为参赛者和编程爱好者提供有价值的参考。 ... [详细]
  • 本文探讨了如何在C#应用程序中通过选择ComboBox项从MySQL数据库中检索数据值。具体介绍了在事件处理方法 `comboBox2_SelectedIndexChanged` 中可能出现的常见错误,并提供了详细的解决方案和优化建议,以确保数据能够正确且高效地从数据库中读取并显示在界面上。此外,还讨论了连接字符串的配置、SQL查询语句的编写以及异常处理的最佳实践,帮助开发者避免常见的陷阱并提高代码的健壮性。 ... [详细]
  • 在Android应用开发中,实现与MySQL数据库的连接是一项重要的技术任务。本文详细介绍了Android连接MySQL数据库的操作流程和技术要点。首先,Android平台提供了SQLiteOpenHelper类作为数据库辅助工具,用于创建或打开数据库。开发者可以通过继承并扩展该类,实现对数据库的初始化和版本管理。此外,文章还探讨了使用第三方库如Retrofit或Volley进行网络请求,以及如何通过JSON格式交换数据,确保与MySQL服务器的高效通信。 ... [详细]
  • 在Java分层设计模式中,典型的三层架构(3-tier application)将业务应用细分为表现层(UI)、业务逻辑层(BLL)和数据访问层(DAL)。这种分层结构不仅有助于提高代码的可维护性和可扩展性,还能有效分离关注点,使各层职责更加明确。通过合理的设计和实现,三层架构能够显著提升系统的整体性能和稳定性。 ... [详细]
  • Python 编程技巧:实现字符串中字符大小写的转换 ... [详细]
  • Java解析YAML文件并转换为JSON格式(支持JSON与XML的结构化查询)
    本文探讨了如何利用Java解析YAML文件并将其转换为JSON格式,同时支持JSON和XML的结构化查询。YAML、JSON和XML这三种数据格式通过其名称作为文件扩展名,便于区分和使用。文章详细介绍了这些格式的层次结构和数据表示方法,并重点讨论了在数据传输过程中,XML的特性和优势。此外,还提供了具体的代码示例和实现步骤,帮助开发者高效地进行数据格式转换和查询操作。 ... [详细]
author-avatar
小虎
每一天,不管用什么方式,我都要变得越来越好!
PHP1.CN | 中国最专业的PHP中文社区 | DevBox开发工具箱 | json解析格式化 |PHP资讯 | PHP教程 | 数据库技术 | 服务器技术 | 前端开发技术 | PHP框架 | 开发工具 | 在线工具
Copyright © 1998 - 2020 PHP1.CN. All Rights Reserved | 京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有