一、高并发编程为什么让人头疼
写过高并发程序的开发者大概都有同感：逻辑简单，跑得很快；一旦上了并发，问题就开始成倍增加。线程之间互相干扰、数据在不同时刻被不同线程修改、死锁和竞态条件时不时冒出来……这些问题的根子在于共享可变状态。当多个线程同时访问同一段数据时，如果没有适当的保护机制，就会出现不可预测的结果。
Scala语言从设计之初就充分考虑了并发场景。它的核心优势在于把不可变数据、函数式编程和高阶抽象封装在了一起，让开发者可以用更少的心智负担来处理并发问题。这篇文章会从Actor模型、Future与Promise、线程安全实践三个维度，带你走进Scala高并发编程的核心世界。
二、Actor模型：用消息传递化解并发难题
2.1 为什么需要Actor
传统的多线程编程采用的是"共享内存+锁"的模型。线程之间通过共享变量来通信，为了防止冲突，你需要加锁、释放锁、处理死锁，代码很快变得又复杂又脆弱。
Actor模型换了一个思路：每个Actor是一个独立的实体，它有自己的状态和消息处理能力。Actor之间不直接共享内存，而是通过发送消息来通信。每个Actor有且只有一个处理线程，同一个Actor内部的消息是顺序处理的，所以不需要加锁就能保证状态的一致性。
你可以把Actor想象成一个个小邮差，每个邮差有自己的信箱（消息队列）和一套处理规则（行为逻辑）。当你要和一个Actor通信时，只需要往它的信箱里投递消息，它会按照顺序一封一封地处理。
2.2 Actor的实现与通信
下面这个示例展示了Akka框架中Actor的基本用法。Akka是Scala生态中最主流的Actor库，它封装了Actor模型的底层细节，让你可以专注于业务逻辑。
// 技术栈：Scala + Akka Actor
import akka.actor.{Actor, ActorRef, ActorSystem, Props}
// 定义一个订单处理Actor
class OrderProcessor extends Actor {
// Actor内部的私有状态
private var orderCount = 0
private val orders = scala.collection.mutable.ArrayBuffer[String]()
override def receive: Receive = {
// 处理提交订单消息
case SubmitOrder(orderId: String) =>
orderCount += 1
orders += s"[$orderId] 已提交"
sender() ! OrderAccepted(orderId, orderCount)
// 处理查询订单消息
case QueryOrders =>
sender() ! AllOrders(orders.toList)
// 处理重置消息
case ResetOrders =>
orderCount = 0
orders.clear()
sender() ! ResetDone
}
}
// 定义所有消息类型
case class SubmitOrder(orderId: String)
case class QueryOrders
case class ResetOrders
case class OrderAccepted(orderId: String, totalCount: Int)
case class AllOrders(orders: List[String])
case class ResetDone
// 主程序入口
object ActorDemo extends App {
// 创建Actor系统，系统名称用于标识
val system = ActorSystem("OrderSystem")
// 创建OrderProcessor的Actor实例
val processor: ActorRef = system.actorOf(Props[OrderProcessor], "orderProcessor")
// 发送提交订单消息
processor ! SubmitOrder("ORD-001")
processor ! SubmitOrder("ORD-002")
processor ! SubmitOrder("ORD-003")
// 发送查询消息
Thread.sleep(200)
processor ! QueryOrders
Thread.sleep(1000)
// 关闭Actor系统
system.terminate()
}
上面这个示例中，OrderProcessor是一个Actor，它内部维护了订单数量和订单列表。当外部发送SubmitOrder消息时，它会更新状态并回复OrderAccepted。因为每个Actor的消息是顺序处理的，所以orderCount的自增操作天然就是安全的，不需要加锁。
2.3 Actor的进阶：守护进程与消息优先级
在实际项目中，Actor通常不是一个孤立存在的。你可以设置Actor之间的守护关系，当父Actor停止时，子Actor也会跟着停止。Akka提供了context.actorOf方法来创建子Actor，并自动建立守护关系。
// 技术栈：Scala + Akka Actor
import akka.actor.{Actor, ActorRef, ActorSystem, Props}
import akka.pattern.ask
import akka.util.Timeout
import scala.concurrent.duration._
import scala.concurrent.Await
// 数据验证Actor
class Validator extends Actor {
override def receive: Receive = {
case data: String =>
if (data.nonEmpty && data.length <= 100) {
sender() ! Valid(data)
} else {
sender() ! Invalid(data)
}
}
}
case class Valid(data: String)
case class Invalid(data: String)
// 数据处理管道Actor
class DataPipeline extends Actor {
// 创建子Actor，由当前Actor守护
private val validator: ActorRef = context.actorOf(Props[Validator], "validator")
override def receive: Receive = {
case raw: String =>
// 把数据发给子Actor处理，结果回传给自己
import context.dispatcher
validator.ask(raw).mapTo[String].onComplete {
case scala.util.Success(result) =>
sender() ! PipelineResult(result)
case scala.util.Failure(ex) =>
sender() ! PipelineError(ex.getMessage)
}
}
}
case class PipelineResult(data: String)
case class PipelineError(message: String)
// 主程序入口
object PipelineDemo extends App {
implicit val timeout: Timeout = Timeout(5.seconds)
val system = ActorSystem("PipelineSystem")
val pipeline: ActorRef = system.actorOf(Props[DataPipeline], "pipeline")
// 发送数据
val future1 = (pipeline ? "Hello, World!").mapTo[PipelineResult]
val future2 = (pipeline ? "").mapTo[PipelineError]
// 等待结果
val r1 = Await.result(future1, 5.seconds)
val r2 = Await.result(future2, 5.seconds)
println(s"成功: $r1")
println(s"失败: $r2")
system.terminate()
}
这个示例展示了Actor之间通过ask模式进行请求-响应通信。ask本质上是一个便捷方法，它发送消息并返回一个Future，当Actor回复时，这个Future会完成。这种模式非常适合需要等待结果的场景。
三、Future与Promise：异步编程的利器
3.1 Future与Promise的基本原理
Future是Scala中表示异步计算的抽象。你可以把它理解成一张"承诺单"——它承诺将来会给你一个结果，但这个结果可能已经完成，也可能还在处理中。你不需要关心这个结果是怎么计算出来的，你只需要关心它最终是什么。
Promise和Future是一对搭档。Promise是一个可以被手动完成的可变引用，它可以被赋值为Success（成功）或Failure（失败）。当你调用promise.future时，就会得到一个对应的Future，这个Future会在Promise被完成时同步完成。
简单来说：Promise是生产者，你负责给它一个结果；Future是消费者，你负责从这个结果中获取数据。
// 技术栈：Scala
import scala.concurrent.{Future, Promise, Await}
import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global
import scala.util.{Success, Failure}
object FuturePromiseDemo {
def main(args: Array[String]): Unit = {
// 示例1：手动使用Promise
val promise = Promise[Int]()
val future = promise.future
// 模拟异步计算
new Thread(() => {
Thread.sleep(1000)
// 模拟成功情况
promise.success(100)
}).start()
// 注册完成回调
future.onComplete {
case Success(value) => println(s"计算完成，结果: $value")
case Failure(ex) => println(s"计算失败: ${ex.getMessage}")
}
// 阻塞等待结果
val result = Await.result(future, 5.seconds)
println(s"阻塞获取结果: $result")
// 示例2：Future的链式映射
val baseFuture = Future {
Thread.sleep(500)
10
}
val mappedFuture = baseFuture
.map(_ * 2) // 将结果乘以2
.flatMap { x => // 如果x大于20则再映射，否则失败
if (x > 20) Future.successful(x + 10)
else Future.failed(new RuntimeException("值太小"))
}
.recover { case _: RuntimeException => -1 } // 失败时恢复为-1
val finalResult = Await.result(mappedFuture, 5.seconds)
println(s"链式映射结果: $finalResult")
// 示例3：并行执行多个Future
val futures = List(
Future { Thread.sleep(300); "A" },
Future { Thread.sleep(500); "B" },
Future { Thread.sleep(200); "C" }
)
val combined = Future.sequence(futures)
val results = Await.result(combined, 5.seconds)
println(s"并行结果: $results")
// 示例4：超时控制
val slowFuture = Future {
Thread.sleep(3000)
"太慢了"
}
val withTimeout = slowFuture
.recoverAfter(2.seconds)(new TimeoutException("超时"))
try {
Await.result(withTimeout, 5.seconds)
} catch {
case e: TimeoutException => println(s"捕获超时: ${e.getMessage}")
}
class TimeoutException(msg: String) extends Exception(msg)
}
}
3.2 Future的常见操作详解
Future提供了丰富的操作符，让你可以像操作集合一样操作异步计算：
map：对Future中的值进行变换，不会改变Future的类型。比如Future[Int].map(_.toString)得到Future[String]。flatMap：对Future中的值进行变换，并且变换函数本身返回一个Future。比如Future[Int].flatMap(x => Future(x + 1))得到Future[Int]。zip：合并两个Future，得到包含二者结果对的Future。sequence：将List[Future[T]]转换为Future[List[T]]，所有Future都成功时才成功。recover：捕获失败并转换为成功结果。recoverWith：捕获失败并返回一个新的Future。
3.3 错误处理与超时控制
在高并发场景中，错误处理和超时控制是不可或缺的。Future的recover和recoverWith方法提供了强大的错误恢复能力，而recoverAfter则允许你在指定时间后切换为另一个Future。
超时控制特别重要，因为如果一个Future长时间不完成，可能会阻塞主流程。使用recoverAfter可以优雅地处理这种情况。
// 技术栈：Scala
import scala.concurrent.{Future, Await}
import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global
object ErrorHandlingDemo {
// 模拟一个可能失败的异步操作
def riskyOperation(id: Int): Future[String] = Future {
if (id == 3) {
throw new RuntimeException(s"操作$id失败了")
}
Thread.sleep(500)
s"操作$id成功"
}
def main(args: Array[String]): Unit = {
// 批量执行，忽略单个失败
val operations = (1 to 5).map(riskyOperation)
val results = Future.sequence(operations)
results.onComplete {
case scala.util.Success(res) =>
println(s"全部成功: $res")
case scala.util.Failure(ex) =>
println(s"部分失败: ${ex.getMessage}")
}
// 使用recover处理单个失败
val safeOps = (1 to 5).map { id =>
riskyOperation(id).recover {
case ex: RuntimeException => s"操作$id失败，已恢复: ${ex.getMessage}"
}
}
val safeResults = Future.sequence(safeOps)
val finalRes = Await.result(safeResults, 5.seconds)
println(s"安全结果: $finalRes")
// 超时控制示例
val timedFuture = Future {
Thread.sleep(4000)
"数据已获取"
}.recoverAfter(2.seconds)(new Exception("请求超时"))
try {
val result = Await.result(timedFuture, 5.seconds)
println(s"结果: $result")
} catch {
case e: Exception => println(s"异常: ${e.getMessage}")
}
}
}
四、线程安全实践：锁、原子操作与不可变数据
4.1 不可变数据的天然线程安全
Scala的哲学是"不可变优先"。当你创建一个不可变集合或不可变对象后，它的状态永远不会改变。既然状态不会变，那么多个线程同时读取它自然也不会出问题。这是Scala并发编程的第一道防线。
// 技术栈：Scala
object ImmutableSafetyDemo {
// 不可变集合，多线程读取安全
val safeList: List[Int] = List(1, 2, 3, 4, 5)
val safeMap: Map[String, String] = Map("name" -> "Alice", "age" -> "30")
// 可变集合，多线程修改不安全
import scala.collection.mutable.ListBuffer
val unsafeList = ListBuffer(1, 2, 3)
// 不可变对象
case class Person(name: String, age: Int)
def main(args: Array[String]): Unit = {
// 多线程读取不可变集合——安全
val readThreads = (1 to 5).map { i =>
new Thread(() => {
println(s"线程$i读取: ${safeList.sum}, ${safeMap("name")}")
})
}
readThreads.foreach(_.start())
readThreads.foreach(_.join())
// 演示不可变对象的拷贝修改
val original = Person("Alice", 30)
val updated = original.copy(age = 31)
println(s"原始: $original, 更新: $updated")
}
}
4.2 锁机制的合理使用
当确实需要共享可变状态时，锁是必要的。Scala支持Java的标准锁，包括ReentrantLock、ReadWriteLock等。但锁的使用需要非常小心——过度使用会导致死锁，使用不当会导致性能瓶颈。
// 技术栈：Scala
import java.util.concurrent.locks.ReentrantReadWriteLock
import scala.collection.mutable
object LockDemo {
// 使用写锁保护的可变共享状态
private val rwLock = new ReentrantReadWriteLock()
private val writeLock = rwLock.writeLock()
private val readLock = rwLock.readLock()
private val sharedMap: mutable.Map[String, Int] = mutable.Map.empty
// 写操作：获取写锁
def put(key: String, value: Int): Unit = {
writeLock.lock()
try {
sharedMap(key) = value
println(s"写入: $key -> $value, 当前Map: $sharedMap")
} finally {
writeLock.unlock()
}
}
// 读操作：获取读锁
def get(key: String): Int = {
readLock.lock()
try {
sharedMap.getOrElse(key, -1)
} finally {
readLock.unlock()
}
}
def main(args: Array[String]): Unit = {
// 多个写线程
val writeThreads = (1 to 5).map { i =>
new Thread(() => put(s"key_$i", i))
}
// 多个读线程
val readThreads = (1 to 3).map { i =>
new Thread(() => println(s"读取: ${get(s"key_$i")}"))
}
writeThreads.foreach(_.start())
writeThreads.foreach(_.join())
readThreads.foreach(_.start())
readThreads.foreach(_.join())
}
}
注意finally块中的unlock调用——这是确保锁被释放的关键，即使业务逻辑抛出异常也能保证锁被释放。
4.3 并发集合的使用
JDK提供了ConcurrentHashMap等并发容器，Scala生态中也有TrieMap等并发集合。这些集合在内部处理了并发控制，比手动加锁更便捷。
// 技术栈：Scala
import scala.collection.concurrent.TrieMap
import java.util.concurrent.atomic.{AtomicInteger, AtomicLong}
object ConcurrentCollectionDemo {
// TrieMap是Scala中的并发哈希Map
private val concurrentMap: TrieMap[String, Int] = TrieMap.empty
// AtomicInteger是Java提供的原子整型操作
private val counter: AtomicInteger = new AtomicInteger(0)
// AtomicLong是原子长整型操作
private val totalSum: AtomicLong = new AtomicLong(0)
def main(args: Array[String]): Unit = {
// 并发写入
val writers = (1 to 10).map { i =>
new Thread(() => {
concurrentMap += (s"user_$i" -> i)
counter.incrementAndGet()
totalSum.addAndGet(i)
})
}
writers.foreach(_.start())
writers.foreach(_.join())
println(s"并发Map内容: $concurrentMap")
println(s"写入计数: ${counter.get()}")
println(s"总和: ${totalSum.get()}")
// 并发迭代
val readers = (1 to 3).map { _ =>
new Thread(() => {
concurrentMap.foreach { case (k, v) =>
println(s"读取: $k -> $v")
}
})
}
readers.foreach(_.start())
readers.foreach(_.join())
}
}
TrieMap基于Trie树结构实现，在读操作上有极高性能，并且支持并发写入。AtomicInteger和AtomicLong使用CPU的CAS（Compare-And-Swap）指令实现无锁操作，性能优于传统的synchronized。
五、应用场景与实战案例
5.1 高并发订单处理系统
在电商系统中，订单处理是典型的高并发场景。每个订单可以建模为一个Actor，订单状态流转通过消息传递完成。多个订单之间互不影响，单个订单内部的消息顺序保证了状态一致性。
// 技术栈：Scala + Akka Actor
import akka.actor.{Actor, ActorSystem, Props}
// 订单状态Actor
class OrderActor(orderId: String) extends Actor {
private var status: String = "CREATED"
private val history: scala.collection.mutable.ArrayBuffer[String] = ArrayBuffer("CREATED")
override def receive: Receive = {
case "PAY" =>
if (status == "CREATED") {
status = "PAID"
history += "PAID"
sender() ! s"订单$orderId已支付"
} else {
sender() ! s"订单$orderId状态不允许支付，当前状态: $status"
}
case "SHIP" =>
if (status == "PAID") {
status = "SHIPPED"
history += "SHIPPED"
sender() ! s"订单$orderId已发货"
} else {
sender() ! s"订单$orderId状态不允许发货，当前状态: $status"
}
case "HISTORY" =>
sender() ! history.toList
}
}
// 订单管理器Actor
class OrderManager extends Actor {
private val orders = scala.collection.mutable.Map[String, Actor]()
override def receive: Receive = {
case CreateOrder(orderId: String) =>
val ref = context.actorOf(Props(new OrderActor(orderId)), s"order_$orderId")
orders(orderId) = ref
sender() ! Created(orderId)
case SendMessage(orderId: String, msg: String) =>
orders.get(orderId).foreach(_ ! msg)
}
}
case class CreateOrder(orderId: String)
case class SendMessage(orderId: String, msg: String)
case class Created(orderId: String)
object OrderSystem extends App {
val system = ActorSystem("OrderSystem")
val manager = system.actorOf(Props[OrderManager], "manager")
manager ! CreateOrder("ORD-001")
Thread.sleep(100)
manager ! SendMessage("ORD-001", "PAY")
Thread.sleep(100)
manager ! SendMessage("ORD-001", "SHIP")
Thread.sleep(500)
system.terminate()
}
5.2 异步数据管道处理
在数据管道中，Future和Promise非常适合处理异步数据流。你可以将数据读取、清洗、转换、写入等步骤都建模为Future，然后通过flatMap将它们串联起来。
// 技术栈：Scala
import scala.concurrent.{Future, Await}
import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global
object DataPipelineDemo {
// 模拟从数据库读取数据
def readData(): Future[List[Int]] = Future {
Thread.sleep(200)
List(1, 2, 3, 4, 5)
}
// 模拟数据清洗
def cleanData(data: List[Int]): Future[List[Int]] = Future {
Thread.sleep(100)
data.filter(_ > 0)
}
// 模拟数据转换
def transformData(data: List[Int]): Future[List[String]] = Future {
Thread.sleep(150)
data.map(x => s"值_${x * 10}")
}
// 模拟数据写入
def writeData(data: List[String]): Future[Unit] = Future {
Thread.sleep(100)
data.foreach(println)
}
def main(args: Array[String]): Unit = {
// 使用for推导串联数据管道
val pipeline: Future[Unit] = for {
rawData <- readData()
cleanData <- cleanData(rawData)
transformed <- transformData(cleanData)
_ <- writeData(transformed)
} yield ()
Await.result(pipeline, 10.seconds)
println("数据管道处理完成")
}
}
5.3 定时任务与并发调度
在实际项目中，你经常需要定时执行某些任务，比如定时清理缓存、定时同步数据。Scala的调度器可以方便地创建定时Future。
// 技术栈：Scala
import scala.concurrent.{Future, ExecutionContext, Await}
import scala.concurrent.duration._
import scala.concurrent.ExecutionContext.Implicits.global
object ScheduledTaskDemo {
// 创建一个延迟执行的任务
def delayedTask(delay: FiniteDuration): Future[String] = {
Future {
Thread.sleep(delay.toMillis)
s"延迟${delay.toSeconds}秒后执行"
}
}
def main(args: Array[String]): Unit = {
// 延迟3秒后执行
val delayedFuture = delayedTask(3.seconds)
val result = Await.result(delayedFuture, 5.seconds)
println(result)
// 批量启动并行Future
val tasks = (1 to 5).map { i =>
Future {
Thread.sleep(i * 500)
s"任务$i完成"
}
}
val allResults = Future.sequence(tasks)
val results = Await.result(allResults, 5.seconds)
println(s"并行任务结果: $results")
}
}
六、技术优缺点分析
6.1 Actor模型的优缺点
优点：
- 天然支持高并发，Actor之间通过消息通信，避免了共享内存的竞争
- 每个Actor内部消息顺序处理，不需要显式加锁
- 支持Actor的层级结构，便于构建复杂的系统架构
- Akka框架成熟稳定，社区活跃，文档丰富
缺点：
- 调试困难，消息是异步发送的，出问题时很难追踪调用链
- 消息传递有一定的开销，对于简单的共享内存场景可能不是最优解
- Actor的状态是局部的，跨Actor的数据一致性需要额外处理
- 学习曲线较陡，特别是对于习惯面向对象编程的开发者
6.2 Future/Promise的优缺点
优点：
- 使用简便，API设计优雅，for推导语法让代码可读性强
- 与Scala的不可变数据理念天然契合
- 支持链式操作，可以方便地组合多个异步操作
- 标准库提供丰富的错误处理机制
缺点：
- 异常处理需要特别注意，遗漏的异常可能导致静默失败
- 线程池管理需要开发者自行关注，资源泄漏风险
- 没有内置的超时机制（虽然可以用recoverAfter实现）
- 对于复杂的并发控制（如分布式事务）支持不够
6.3 线程安全实践的优缺点
优点：
- 不可变数据从根源上消除了并发问题，是最安全的方案
- 并发集合和原子操作提供了便捷的并发工具
- 锁机制提供了最细粒度的并发控制能力
缺点：
- 锁机制使用不当会导致死锁和性能问题
- 并发集合的性能通常低于同步集合
- 原子操作只适用于简单的读写场景，复杂逻辑仍然需要锁
七、注意事项与最佳实践
7.1 避免常见的并发陷阱
第一，不要在Future中做阻塞操作。如果一个Future中调用了数据库查询、文件IO等阻塞操作，它会占用线程池中的线程，影响其他Future的执行。建议使用专门的IO线程池处理阻塞任务。
第二，注意Future的异常传播。在flatMap链中，如果一个步骤抛出异常，后续的步骤不会执行，而是将异常向上传播。如果需要忽略异常继续执行，请使用recover。
第三，不要过度使用synchronized。synchronized虽然简单，但它的性能开销较大，且在竞争激烈的场景下容易成为瓶颈。优先考虑不可变数据、并发集合和原子操作。
7.2 Actor设计的最佳实践
第一，保持Actor消息处理快速。Actor是单线程处理的，如果消息处理中有耗时操作，会阻塞后续消息。对于耗时操作，应该将Actor拆分为更细粒度的子Actor。
第二，避免在Actor中保存过多状态。Actor的状态应该是局部的、最小的。如果状态需要共享，考虑通过消息传递而不是直接访问。
第三，使用Actor系统统一管理生命周期。不要让Actor自己创建子Actor而不建立守护关系，这样在父Actor停止时子Actor会变成孤儿。
7.3 Future使用的最佳实践
第一，始终指定执行上下文。Future的创建和执行需要ExecutionContext，如果不指定，会使用默认的ExecutionContext，可能不是你期望的行为。建议在项目级别定义统一的ExecutionContext。
第二，注意Future的超时控制。如果Future可能长时间不完成，应该使用recoverAfter添加超时机制。
第三，避免在Future内部直接引用可变状态。虽然Scala没有编译期阻止你在Future中修改外部可变变量，但这样做会导致不可预测的并发问题。
7.4 并发测试的注意事项
测试并发代码比测试同步代码困难得多。竞态条件可能只在特定时机才会触发，在测试环境中不一定能复现。建议：
第一，使用确定性的测试工具，比如Akka TestKit提供的时间控制能力。
第二，对并发代码进行压力测试，模拟高并发场景，观察是否出现异常。
第三，在代码审查时特别关注共享可变状态的使用，这是并发问题的高发区域。
八、文章总结
Scala的高并发编程核心在于三条路径：Actor模型通过消息传递消除共享内存的竞争，适合处理高并发的业务逻辑；Future和Promise通过异步编程抽象简化了非阻塞操作的处理；而线程安全实践则从数据层面为并发安全兜底——不可变数据是最优解，并发集合和原子操作是补充，锁机制是最后防线。
在实际项目中，这三条路径往往需要组合使用。比如，一个高并发订单系统可能用Actor管理订单生命周期，用Future处理异步的支付回调，用不可变数据结构保存订单快照。关键在于理解每种机制的适用场景和局限性，在正确的地方使用正确的工具。
并发编程没有银弹。Actor模型不是万能的，它在某些场景下反而增加了复杂性；Future的优雅API背后需要你对线程池和异常传播有深入理解；而线程安全实践的核心在于"避免共享可变状态"这个基本原则。
最后想说的是，并发编程的关键不是掌握多少高级技巧，而是建立正确的并发思维——理解竞态条件是怎么产生的，理解死锁是怎么形成的，理解为什么不可变数据是并发安全的基石。当这些基础概念清晰了，Actor、Future、并发集合这些工具用起来就会得心应手。
评论
围绕“Scala高并发编程核心机制：Actor模型、Future/Promise及线程安全实践”参与讨论