利用 Swift Actor 保护可变状态

当两个单独线程同时访问同一可变状态时，会发生数据竞争。它们构建起来很简单，但出了名的难以调试。了解如何才能停止与 Swift Actor 的这些数据竞争，从而帮助同步您的代码中的数据访问。探索 Actor 如何工作以及如何相互共享值。了解 Actor 隔离如何影响协议一致性。最后，一起来探索主要 Actor，这是一种确保您的代码始终根据需要在主要线程上运行的新方式。为了充分了解本节内容，我们建议先观看“认识 Swift 中的 async/await”。

资源

相关视频

WWDC22

WWDC21

下载

♪低音音乐播放♪ ♪ 达瑞欧瑞辛：大家好我叫达瑞欧瑞辛我是Apple的Swift团队的工程师今天我和同事道格将讨论Swift中的Actor 以及在并行 Swift App 中如何利用它们来保护可变状态编写并行程序的根本难题之一是避免数据竞争当两个单独的线程同时访问相同的数据时会发生数据竞争并且这之中至少一个访问是写入数据竞争构建起来很简单但出了名的难以除错这是一个带有一个操作的简单计数器类会增加计数器并返回其新值假设我们继续并尝试从两个并行任务增加这是一个坏主意根据执行的时间我们可能会得到1然后2 或者2然后是1 这是意料之中的在这两种情况下计数器将保持一致状态但是因为我们引入了数据竞赛我们也可以得到1和1 如果两个任务都读取0 并写入一个1 或甚至是2和2 如果返回语句发生在两个增量操作之后数据竞争出了名地难以避免和除错他们需要非本地推理因为数据访问导致竞争可能在程序的不同部分它们是不确定的因为操作系统的调度程序在每次运行程序时可能会以不同的方式交错并行任务数据竞争是由共享的可变状态引起的如果你的数据没有更改或未在多个并行任务之间共享你不能在上面进行数据竞赛避免数据竞争的一种方法是通过使用值语义消除共享的可变状态对于值类型的变量所有变异都是局部的此外值语义类型的“let”属性是真正不可变的因此从不同的并行任务访问它们是安全的 Swift自成立以来一直在推广值语义因为它们使我们的程序更容易推理这些相同的东西也使它们可以安全地用于并行程序在这个例子中我们创建了一个包含一些值的数组接下来我们将该数组分配给第二个变量现在我们为数组的每个副本附加一个不同的值当我们在最后打印两个数组时我们看到两个副本都包含值数组被初始化但每个附加值只存在于相应的、我们将它们附加进去的副本中 Swift标准库中的大多数类型都具有值语义包括集合类型例如字典或在这个例子中是数组现在我们已经确定值语义解决了我们所有的数据竞争让我们继续通过将其转换为结构体来使我们的计数器成为值类型我们还必须将增量函数标记为变异所以它可以修改值属性当我们现在尝试修改计数器时我们会得到一个编译器错误因为计数器是一个let 这可以防止我们对其进行变异现在似乎很诱人的是改变计数器变量到var以使其可变但这会让我们再次面临竞争条件因为计数器将再将通过两个并行任务被引用幸运的是我们的编译器很靠谱并且不允许我们编译这个不安全的代码我们可以改为分配计数器到每个并行任务中的局部可变变量当我们现在执行我们的例子时它将始终为两个并行任务打印1 但即使我们的代码现在是无竞争的这种行为不再是我们想要的这说明了在需要共享可变状态的地方还是有案例的当我们在并行程序中共享可变状态时我们需要某种形式的同步确保并行使用我们共享的可变状态不会导致数据竞争有许多用于同步的原语从像原子和锁这样的低级工具到更高级别的构造如串行调度队列这些原语中的每一个都有其不同的优势但它们都具有相同的严重弱点他们需要仔细的纪律才能准确地使用而且是每一次否则我们会以数据竞争告终这时候就轮到Actor出场了 Actor是一种共享可变状态的同步机制 Actor有自己的状态并且该状态与程序的其余部分隔离访问该状态的唯一方法是通过Actor 并且每当你通过Actor时 Actor的同步机制确保没有其他代码同时访问Actor的状态这为我们提供了相同的与我们从手动使用锁或者串行调度队列得到的互斥属性至于Actor 这是Swift提供的基本保证你不能忘记执行同步因为如果你这么做 Swift会产生一个编译器错误 Actor是Swift中的一种新类型它们提供与Swift中所有命名类型相同的功能它们可以有属性、方法初始值设定项下标诸如此类的它们可以符合协议并通过扩展进行扩充和类一样它们是引用类型因为Actor的目的是表达共享的可变状态实际上 Actor类型的主要区别特征是它们从程序的其余部分隔离了它们的实例数据并确保对这些数据的同步访问他们所有的特殊行为都遵循这些核心思想在这里我们将我们的计数器定义为Actor类型我们仍然有计数器的实例属性值以及增加该值并返回新值的增量方法不同之处在于 Actor将确保不会同时访问该值在这种情况下这意味着增量方法在调用时将运行到完成而没有在Actor上执行任何其他代码该保证消除了Actor状态数据竞争的可能性让我们回到我们的数据竞争示例我们再次有两个并行任务试图要增加相同的计数器 Actor的内部同步机制会在增量调用可以开始之前确保另一个的执行完成所以我们可以得到1和2或2和1 因为两者都是有效的并行执行但我们不能两次得到相同的计数或跳过任何值因为Actor的内部同步已经消除了Actor状态的数据竞争的可能性让我们考虑一下当两个并行任务都尝试同时增加计数器时会怎么样其中一个会第一个到达那里另一个必须等待轮到它但是我们如何确保第二个任务可以耐心地等待Actor的机会呢？ Swift针对这有一个机制每当你从外部与Actor互动时都是异步进行的如果Actor很忙那么你的代码将卡顿所以你运行的CPU 可以做其他有用的工作当Actor再次获得自由时它会唤醒你的代码“恢复执行” 所以调用可以在Actor上运行本例子中的await关键词表示着对Actor的异步调用可能会涉及这样的挂起通过添加不必要的缓慢复位操作我们来进一步扩展我们的反例此操作将值设置回0 然后用适当的次数调用增量使计数器达到新值这个resetSlowly方法会在反Actor类型中的扩展被定义所以它在Actor内部这意味着它可以直接访问Actor的状态它将计数器值重置为0 它还可以同步调用Actor的其他方法例如在调用增量时不需要await 因为我们已经知道我们正在运行Actor 这是Actor的重要属性 Actor上的同步代码从运行到完成总是不被打扰所以我们可以按顺序推理同步代码无需考虑并行性对我们的 Actor状态的影响我们已经强调过我们的同步代码是不间断运行的但是Actor经常会相互或与系统中的其他异步代码交互让我们花几分钟时间谈谈异步代码和Actor 但首先我们需要一个更好的例子在这里我们正在构建一个图像下载器Actor 它负责从另一个服务中下载图像它还将下载的图像存储在缓存中以避免多次下载相同的图像逻辑流程很简单检查缓存下载图像然后在返回之前将图像记录在缓存中因为我们是Actor 此代码不受低级数据竞争的影响可以同时下载任意数量的图像 Actor的同步机制保证只有一个任务可以执行代码一次访问缓存实例属性因此无法破坏缓存也就是说这里的await关键词传达了非常重要的信息每当发生await时就意味着该函数可以在此时暂停它放弃自己的CPU 以便程序中的其他代码可以执行这会影响整个程序状态在你的功能恢复时整个程序状态将发生变化重要的是确保你没有对await之前的状态做出可能在await之后不成立的假设想象一下我们有两个不同的并行任务试图同时获取相同的图像第一个看到没有缓存条目继续从服务器开始下载图像然后被挂起因为下载需要一段时间当第一个任务是下载图像时可能会在相同URL下将新图像部署到服务器现在第二个并行任务尝试获取该URL下的图像它也看不到缓存条目因为第一次下载尚未完成然后开始第二次下载图像它也会在下载完成时暂停过了一会儿其中一个下载… 让我们假设它是第一个将会完成并且它的任务将在Actor上恢复执行它填充缓存并返回猫的结果图像现在第二个任务已经完成下载所以它被唤醒它用它得到的悲伤猫的图像覆盖缓存中的相同条目因此即使缓存中已经填充了图像我们现在也会为相同的URL 获得不同的图像这有点意外我们期望一旦缓存了一个图像我们总会为相同的URL 获取相同的图像所以我们的用户界面保持一致至少在我们手动清除缓存之前是这样但是在这里缓存的图像会意外地变动我们没有任何低级别的数据竞争但是因为我们在await中对状态进行了假设我们最终发现了一个潜在的错误这里的解决方法是在await之后检查我们的假设如果我们恢复时缓存中已经有一个条目我们保留原始版本并丢弃新版本更好的解决方案是完全避免冗余下载我们已将该解决方案放入与此视频相关的代码中 Actor可重入可防止死锁并保证前进但它要求你在每个await中检查你的假设为了更好地设计可重入性请在同步代码中执行Actor状态的突变理想情况下请在同步函数中进行所以所有的状态变化都被很好地封装了状态更改可能涉及暂时将我们的Actor 置于不一致的状态确保在await之前恢复一致性请记住 await是一个潜在的暂停点如果你的代码被挂起在你的代码恢复之前程序和世界将继续前进你对全局状态、时钟、计时器或你的Actor所做的任何假设在await之后都需要检查现在我的同事道格会告诉你更多关于Actor隔离的信息道格？道格格雷戈尔：谢谢达里奥 Actor隔离是Actor类型行为的基础达瑞欧讨论了Swift语言模型通过来自Actor外部的异步交互如何保证Actor隔离在本节中我们将讨论 Actor隔离如何与其他语言功能交互包括协议一致性、闭包和类和其他类型一样 Actor可以遵守协议只要他们能满足协议的要求例如让我们来把这个 LibraryAccount的Actor 符合Equatable协议静态相等方法会根据ID号码比较两个图书馆账户因为该方法是静态的所以没有自身的实例所以它不与Actor隔离相反我们有两个Actor类型的参数而这个静态方法是在这两个参数之外这是可以的因为该实现仅会访问 Actor上的不可变状态让我们进一步扩展我们的示例使我们的图书馆账户遵照可散列的协议这样做需要实现hash(into)操作而我们可以这样做然而 Swift编译器会抱怨这种一致性是不被允许的怎么一回事？好吧以这种方式遵照可散列意味着可以从Actor外部调用此函数但是hash(into)不是异步的所以没有办法保持Actor隔离为了解决这个问题我们可以使这个方法非隔离非隔离意味着此方法被视为在Actor之外即使它在语法上是在Actor身上描述的这意味着它可以满足可散列协议的同步要求因为非隔离方法被视为在Actor之外他们不能在Actor上引用可变状态这种方法很好因为它指的是不可变的ID号码如果我们尝试根据其他东西例如借出书籍的数组进行散列我们会得到一个错误因为从外部访问可变状态将允许数据竞争协议一致性就足够了让我们来谈谈闭包闭包是在一个函数中定义的小函数然后可以将其传递给另一个函数以便稍后调用像函数一样闭包可能是 Actor隔离的或者它可能是非隔离的在这个例子中我们将从我们借出的每本书中阅读一些并返回我们阅读的总页数对reduce的调用涉及执行读取的闭包请注意在此对readSome的调用中没有await 那是因为这个闭包它是在独立于Actor的函数 “read”中形成的本身是Actor隔离的我们知道这是安全的因为reduce操作将同步执行并且无法将闭包转至其他可能导致并行访问的线程现在我们来做一些不同的事情我现在没有时间阅读所以让我们稍后阅读在这里我们创建了一个分离的任务一个分离的任务与Actor正在做的其他工作同时执行闭包因此闭包不能在Actor上否则我们会引入数据竞争所以这个闭包不是孤立于Actor的当它想要调用read方法时它必须异步执行如await所示我们已经谈到了代码的Actor隔离即代码是在Actor内部运行还是在Actor外部运行现在让我们谈谈Actor隔离和数据在我们的图书馆账户示例中我们刻意避免说明图书类型实际上是什么我一直假设它是一个值类型就像一个结构体这是一个不错的选择因为这意味着图书馆账户Actor实例的所有状态是自给自足的如果我们继续调用这个方法来随机选择一本书阅读我们会得到一本我们可以阅读的书我们对这本书所做的更改不会影响Actor 反之亦然然而如果把这本书变成一个类事情就有点不同了我们的图书馆账户Actor现在引用 book类的实例这本身不是问题但是当我们调用方法随机选择书时会发生什么？现在我们有了对Actor 可变状态的引用而这已在Actor之外共享我们创造了数据竞争的潜力现在如果我们去更新书名修改会在Actor内发生在可访问的状态因为访问方法不在Actor上这种修改最终可能会导致数据竞争值类型和Actor 都可以安全地同时使用但是类仍然会带来问题我们有一个可以安全同时使用的类型的名称 “可发送的” 可发送的类型是一种其值可以在不同Actor之间共享的类型如果将一个值从一个地方复制到另一个地方并且两个地方都可以安全地修改自己的副本该值互不干扰该类型可以是可发送的值类型是可发送的因为每个副本都是独立的正如达瑞欧之前所说 Actor类型是可发送的因为它们会同步对其可变状态的访问类也可以是可发送的但前提是它们被仔细地实现例如如果一个类及其所有子类只保存不可变数据那么它可以称为可发送的或者如果类在内部执行同步例如使用锁为了确保安全的并行访问它可以是可发送的但大多数的类都不是这些也不能是可发送的函数不一定是可发送的所以对于可以安全地跨Actor 传递的功能有一种新的函数类型我们很快会再回来说这些你的Actor… 事实上你所有的并行代码应该主要根据可发送的类型进行通信可发送类型能保护代码免受数据竞争这是Swift最终将开始静态检查的属性在那时候跨越Actor的界限传递不可发送的类型将成为错误如何知道一种类型是可发送的？好吧 “可发送的”是一个协议你声明你的类型符合“可发送” 与使用其他协议的方式相同然后Swift将会检查以确保你的类型作为可发送类型是合理的如果Book结构的所有存储属性都是可发送类型则它可以是可发送的假设Author实际上是一个类这意味着…因此作者的数组… 为不可发送 Swift将产生一个编译器错误指示Book为不能发送对于泛型类型它们是否可发送取决于它们的泛型参数我们可以在适当的时候使用条件一致性来传播可发送例如仅当它的两个通用参数都是可发送的配对类型才会是可发送的使用相同的方法得出结论可发送类型的数组本身就是可发送的我们鼓励你将可发送的一致性引进其值可以安全地同时共享的类型在你的Actor中使用这些类型吧然后当Swift开始跨Actor 强制执行可发送你的代码将准备就绪函数本身可以是可发送的意味着跨Actor传递函数值是安全的这对于闭包被限制能做什么来帮助防止数据竞争尤其重要例如一个可发送的闭包不能捕获一个可变的局部变量因为这将允许局部变量上的数据竞争闭包捕获的任何内容都需要是可发送的来确保闭包不能被用来把不可发送类型移动到跨Actor的边界最后一个同步的可发送的闭包是不能Actor隔离的因为这将允许代码从外部在Actor身上运行本次座谈中我们实际上一直依赖着可发送闭包的想法创建分离任务的操作采用了可发送的函数这里写成函数类型中的@Sendable 还记得座谈开始时的反例吗？我们试图构建一个值类型计数器然后我们尝试同时从两个不同的闭包中修改它这将是可变局部变量的数据竞争但是因为分离任务的闭包是可发送的 Swift会在这里产生错误可发送函数类型被用于指示可以发生并行执行的位置从而防止数据竞争这是我们之前看到的另一个例子因为分离任务的闭包是可发送的我们知道它不应该与Actor隔离因此与它的交互必须是异步的可发送类型和闭包通过检查可变状态未在Actor之间共享来帮助维护Actor隔离并且不能同时修改我们主要讨论的是Actor类型以及它们如何与协议、闭包和可发送类型还有一位Actor要讨论… 它很特殊我们称之为主要Actor 在构建 App 时你需要考虑到主线程它是核心用户界面渲染发生的地方也是用户事件交互和被处理的地方与UI共同进行的操作通常需要从主线程执行但是你不想在主线程上完成所有工作如果你在主线程上做了太多的工作比如说因为你有一些缓慢的输入/输出操作或以服务器阻止交互你的UI将会冻结因此当主线程与UI交互时你需要小心地在主线程上进行工作但在计算成本高或等待时间长的操作上请迅速脱离主线所以当我们可以的时候我们会在主线程之外工作然后每当你进行特定操作时在你的代码中调用必须在主线程上执行的 DispatchQueue.main.async 从机制的细节退一步回来看这段代码的结构看起来有点眼熟其实和主线程交互很像与Actor互动如果你知道你已经在主线程上运行你可以安全地访问和更新你的UI状态如果你不在主线程上运行你需要与它异步交互这正是Actor的工作方式有一个特殊的Actor来描述主线程我们称之为主要Actor 主要Actor是代表主线程的Actor 它在两个重要方面与普通Actor不同首先主要Actor会通过主调度队列执行其所有同步这意味着从运行时的角度来看主要Actor是可以通过DispatchQueue.main互换的第二需要在主线程上的代码和数据散落在各处它在SwiftUI、AppKit、UIKit 和其他系统框架中它分布在你自己的视图、视图控制器以及数据模型中面向UI的部分使用Swift并行性你可以用主要Actor特性标记声明表示必须在主要Actor上执行我们已经完成了这里的检出操作所以它总是在主要Actor身上运行如果你从主要Actor之外调用它你需要等待以便执行调用在主线程上异步执行通过标记必须在主线程上运行的代码作为主要Actor 也不需要再更多的猜测关于何时使用DispatchQueue.main了 Swift会确保这段代码总是在主线程上执行类型也可以放在主要Actor身上这使得他们的所有成员和子类成为主要Actor 这对必须与UI交互的代码库的部分来说很有用大多数东西都需要在主线程上运行个别方法可以通过 nonisolated关键词来退出通过来自普通Actor的你熟悉的相同规则通过为面向UI的类型使用主要Actor 和操作并介绍自己的Actor 用于管理其他程序状态你可以构建你的 App 以确保安全以及正确的并行性使用方式在本次座谈中我们讨论了 Actor如何使用Actor隔离保护其可变状态免受并行访问并通过要求从Actor外部进行异步访问来将执行给序列化使用Actor在Swift代码中构建安全的并行抽象吧在实现你的Actor时以及在任何异步代码中请始终为可重入而设计而在你代码中的await 意味着世界可以继续前进并使你的假设无效值类型和Actor会协同工作来消除数据竞争留意那些不处理它们自己同步的类以及其他重新引入共享可变状态的、不可发送的类型最后在与UI交互的代码上使用主要Actor以确保必须在主线程上的代码会总在主线程上运行了解有关如何在你自己的应用中使用Actor的更多信息请查看我们的座谈有关更新Swift并行的 App 并了解更多有关实施Swift的并行模型的信息包括Actor 请查看我们的《幕后花絮》座谈 Actor是Swift并行模型的核心部分它们与async/await 和结构化并行一起工作来让构建正确高效的并行程序更为容易等不及看到你们的成品了 ♪

0:42 - Data races make concurrency hard

class Counter {
    var value = 0

    func increment() -> Int {
        value = value + 1
        return value
    }
}

let counter = Counter()

Task.detached {
    print(counter.increment()) // data race
}

Task.detached {
    print(counter.increment()) // data race
}

2:20 - Value semantics help eliminate data races

var array1 = [1, 2]
var array2 = array1

array1.append(3)
array2.append(4)

print(array1)        // [1, 2, 3]
print(array2)        // [1, 2, 4]

2:59 - Sometimes shared mutable state is required

struct Counter {
    var value = 0

    mutating func increment() -> Int {
        value = value + 1
        return value
    }
}

let counter = Counter()

Task.detached {
    var counter = counter
    print(counter.increment()) // always prints 1
}

Task.detached {
    var counter = counter
    print(counter.increment()) // always prints 1
}

5:23 - Actor isolation prevents unsynchronized access

actor Counter {
    var value = 0

    func increment() -> Int {
        value = value + 1
        return value
    }
}

let counter = Counter()

Task.detached {
    print(await counter.increment())
}

Task.detached {
    print(await counter.increment())
}

7:51 - Synchronous interation within an actor

extension Counter {
    func resetSlowly(to newValue: Int) {
        value = 0
        for _ in 0..<newValue {
            increment()
        }
        assert(value == newValue)
    }
}

9:02 - Check your assumptions after an await: The sad cat

actor ImageDownloader {
    private var cache: [URL: Image] = [:]

    func image(from url: URL) async throws -> Image? {
        if let cached = cache[url] {
            return cached
        }

        let image = try await downloadImage(from: url)

        // Potential bug: `cache` may have changed.
        cache[url] = image
        return image
    }
}

11:50 - Check your assumptions after an await: One solution

actor ImageDownloader {
    private var cache: [URL: Image] = [:]

    func image(from url: URL) async throws -> Image? {
        if let cached = cache[url] {
            return cached
        }

        let image = try await downloadImage(from: url)

        // Replace the image only if it is still missing from the cache.
        cache[url] = cache[url, default: image]
        return cache[url]
    }
}

11:59 - Check your assumptions after an await: A better solution

actor ImageDownloader {

    private enum CacheEntry {
        case inProgress(Task<Image, Error>)
        case ready(Image)
    }

    private var cache: [URL: CacheEntry] = [:]

    func image(from url: URL) async throws -> Image? {
        if let cached = cache[url] {
            switch cached {
            case .ready(let image):
                return image
            case .inProgress(let task):
                return try await task.value
            }
        }

        let task = Task {
            try await downloadImage(from: url)
        }

        cache[url] = .inProgress(task)

        do {
            let image = try await task.value
            cache[url] = .ready(image)
            return image
        } catch {
            cache[url] = nil
            throw error
        }
    }
}

13:30 - Protocol conformance: Static declarations are outside the actor

actor LibraryAccount {
    let idNumber: Int
    var booksOnLoan: [Book] = []
}

extension LibraryAccount: Equatable {
    static func ==(lhs: LibraryAccount, rhs: LibraryAccount) -> Bool {
        lhs.idNumber == rhs.idNumber
    }
}

14:15 - Protocol conformance: Non-isolated declarations are outside the actor

actor LibraryAccount {
    let idNumber: Int
    var booksOnLoan: [Book] = []
}

extension LibraryAccount: Hashable {
    nonisolated func hash(into hasher: inout Hasher) {
        hasher.combine(idNumber)
    }
}

15:32 - Closures can be isolated to the actor

extension LibraryAccount {
    func readSome(_ book: Book) -> Int { ... }
    
    func read() -> Int {
        booksOnLoan.reduce(0) { book in
            readSome(book)
        }
    }
}

16:29 - Closures executed in a detached task are not isolated to the actor

extension LibraryAccount {
    func readSome(_ book: Book) -> Int { ... }
    func read() -> Int { ... }
    
    func readLater() {
        Task.detached {
            await read()
        }
    }
}

17:15 - Passing data into and out of actors: structs

actor LibraryAccount {
    let idNumber: Int
    var booksOnLoan: [Book] = []
    func selectRandomBook() -> Book? { ... }
}

struct Book {
    var title: String
    var authors: [Author]
}

func visit(_ account: LibraryAccount) async {
    guard var book = await account.selectRandomBook() else {
        return
    }
    book.title = "\(book.title)!!!" // OK: modifying a local copy
}

17:39 - Passing data into and out of actors: classes

actor LibraryAccount {
    let idNumber: Int
    var booksOnLoan: [Book] = []
    func selectRandomBook() -> Book? { ... }
}

class Book {
    var title: String
    var authors: [Author]
}

func visit(_ account: LibraryAccount) async {
    guard var book = await account.selectRandomBook() else {
        return
    }
    book.title = "\(book.title)!!!" // Not OK: potential data race
}

20:08 - Check Sendable by adding a conformance

struct Book: Sendable {
    var title: String
    var authors: [Author]
}

20:43 - Propagate Sendable by adding a conditional conformance

struct Pair<T, U> {
    var first: T
    var second: U
}

extension Pair: Sendable where T: Sendable, U: Sendable {
}

24:19 - Interacting with the main thread: Using a DispatchQueue

func checkedOut(_ booksOnLoan: [Book]) {
    booksView.checkedOutBooks = booksOnLoan
}

// Dispatching to the main queue is your responsibility.
DispatchQueue.main.async {
    checkedOut(booksOnLoan)
}

25:01 - Interacting with the main thread: The main actor

@MainActor func checkedOut(_ booksOnLoan: [Book]) {
    booksView.checkedOutBooks = booksOnLoan
}

// Swift ensures that this code is always run on the main thread.
await checkedOut(booksOnLoan)

26:21 - Main actor types

@MainActor class MyViewController: UIViewController {
    func onPress(...) { ... } // implicitly @MainActor

    nonisolated func fetchLatestAndDisplay() async { ... } 
}

正在查找特定内容？在上方输入一个主题，就能直接跳转到相应的精彩内容。