256

我在 Swift 2.x（甚至 1.x）项目中有很多代码，如下所示：

// Move to a background thread to do some long running work
dispatch_async(dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)) {
    let image = self.loadOrGenerateAnImage()
    // Bounce back to the main thread to update the UI
    dispatch_async(dispatch_get_main_queue()) {
        self.imageView.image = image
    }
}

或者像这样延迟执行的东西：

dispatch_after(dispatch_time(DISPATCH_TIME_NOW, Int64(0.5 * Double(NSEC_PER_SEC))), dispatch_get_main_queue()) {
    print("test")
}

或者 Grand Central Dispatch API 的任何其他用途......

现在我已经在 Xcode 8 (beta) 中为 Swift 3 打开了我的项目，我得到了各种各样的错误。他们中的一些人提供修复我的代码，但并非所有修复程序都会产生工作代码。我该怎么办？

4

6 回答 6

356

从一开始，Swift 就提供了一些使 ObjC 和 C 更加 Swifty 的工具，每个版本都添加了更多功能。现在，在 Swift 3 中，新的“作为成员导入”功能允许框架具有某些风格的 C API——在那里你有一个像类一样工作的数据类型，以及一堆全局函数来使用它——更像是 Swift 原生 API。数据类型作为 Swift 类导入，它们相关的全局函数作为这些类的方法和属性导入，一些相关的东西，比如常量集，可以在适当的时候成为子类型。

在 Xcode 8 / Swift 3 beta 中，Apple 已应用此功能（以及其他一些功能）来使 Dispatch 框架更加 Swifty。（还有Core Graphics。）如果你一直在关注 Swift 的开源工作，这不是新闻，但现在是它第一次成为 Xcode 的一部分。

将任何项目迁移到 Swift 3 的第一步应该是在 Xcode 8 中打开它，然后在菜单中选择Edit > Convert > To Current Swift Syntax...。这将应用（在您的审核和批准下）所有重命名的 API 和其他更改所需的所有更改。（通常，一行代码同时受到多个这些更改的影响，因此响应错误修复 - 单独响应可能无法正确处理所有内容。）

结果是，将工作弹回背景并返回的常见模式现在如下所示：

// Move to a background thread to do some long running work
DispatchQueue.global(qos: .userInitiated).async {
    let image = self.loadOrGenerateAnImage()
    // Bounce back to the main thread to update the UI
    DispatchQueue.main.async {
        self.imageView.image = image
    }
}

请注意，我们正在使用.userInitiated而不是旧DISPATCH_QUEUE_PRIORITY常量之一。服务质量 (QoS) 说明符是在 OS X 10.10 / iOS 8.0 中引入的，为系统确定工作优先级和弃用旧的优先级说明符提供了更清晰的方法。有关详细信息，请参阅 Apple关于后台工作和能源效率的文档。

顺便说一句，如果您保留自己的队列来组织工作，那么现在获取队列的方法如下所示（注意这DispatchQueueAttributes是一个OptionSet，因此您使用集合样式的文字来组合选项）：

class Foo { 
    let queue = DispatchQueue(label: "com.example.my-serial-queue",
                           attributes: [.serial, .qosUtility])
    func doStuff() {
        queue.async {
            print("Hello World")
        }
    }
}

以后dispatch_after用来上班吗？这也是队列上的一种方法，它需要 a DispatchTime，它具有各种数字类型的运算符，因此您可以添加整秒或小数秒：

DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) { // in half a second...
    print("Are we there yet?")
}

您可以通过在 Xcode 8 中打开新的 Dispatch API 界面来找到自己的方式——使用 Open Quickly 找到 Dispatch 模块，或者DispatchQueue在您的 Swift 项目/playground 中放置一个符号（如 ）并命令单击它，然后浏览从那里开始的模块。（您可以在 Apple 漂亮的新 API 参考网站和 in-Xcode 文档查看器中找到 Swift Dispatch API，但看起来 C 版本的文档内容还没有移入其中。）

有关更多提示，请参阅迁移指南。

于 2016-06-14T00:58:40.560 回答
149

在 Xcode 8 beta 4 中不起作用...

采用：

DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
    print("Are we there yet?")
}

对于异步两种方式：

DispatchQueue.main.async {
    print("Async1")
}

DispatchQueue.main.async( execute: {
    print("Async2")
})
于 2016-08-13T08:54:34.867 回答
74

这是Swift 4about的一个很好的例子async：

DispatchQueue.global(qos: .background).async {
    // Background Thread
    DispatchQueue.main.async {
        // Run UI Updates or call completion block
    }
}
于 2017-03-01T12:02:36.280 回答
40

在 Xcode 8 中使用：

DispatchQueue.global(qos: .userInitiated).async { }
于 2016-10-09T16:07:08.810 回答
31

Swift 5.2、4 及更高版本

主队列和后台队列

let main = DispatchQueue.main
let background = DispatchQueue.global()
let helper = DispatchQueue(label: "another_thread")

使用异步和同步线程！

 background.async { //async tasks here } 
 background.sync { //sync tasks here }

异步线程将与主线程一起工作。

同步线程将在执行时阻塞主线程。

于 2017-10-17T11:41:52.933 回答
14

Swift 4.1 和 5。我们在代码中的很多地方都使用了队列。因此，我创建了包含所有队列的 Threads 类。如果您不想使用 Threads 类，您可以从类方法中复制所需的队列代码。

class Threads {

  static let concurrentQueue = DispatchQueue(label: "AppNameConcurrentQueue", attributes: .concurrent)
  static let serialQueue = DispatchQueue(label: "AppNameSerialQueue")

  // Main Queue
  class func performTaskInMainQueue(task: @escaping ()->()) {
    DispatchQueue.main.async {
      task()
    }
  }

  // Background Queue
  class func performTaskInBackground(task:@escaping () throws -> ()) {
    DispatchQueue.global(qos: .background).async {
      do {
        try task()
      } catch let error as NSError {
        print("error in background thread:\(error.localizedDescription)")
      }
    }
  }

  // Concurrent Queue
  class func perfromTaskInConcurrentQueue(task:@escaping () throws -> ()) {
    concurrentQueue.async {
      do {
        try task()
      } catch let error as NSError {
        print("error in Concurrent Queue:\(error.localizedDescription)")
      }
    }
  }

  // Serial Queue
  class func perfromTaskInSerialQueue(task:@escaping () throws -> ()) {
    serialQueue.async {
      do {
        try task()
      } catch let error as NSError {
        print("error in Serial Queue:\(error.localizedDescription)")
      }
    }
  }

  // Perform task afterDelay
  class func performTaskAfterDealy(_ timeInteval: TimeInterval, _ task:@escaping () -> ()) {
    DispatchQueue.main.asyncAfter(deadline: (.now() + timeInteval)) {
      task()
    }
  }
}

显示使用主队列的示例。

override func viewDidLoad() {
    super.viewDidLoad()
     Threads.performTaskInMainQueue {
        //Update UI
    }
}
于 2018-09-13T17:59:38.033 回答