本文旨在帮助开发者理解Scala中多线程编程时synchronized关键字的正确使用方法，以及如何避免常见的线程安全问题。通过分析一个具体的案例，我们将深入探讨synchronized的作用范围、线程执行顺序的影响，以及如何确保共享变量的读写操作的原子性，最终提供一个能够正确演示多线程并发修改共享变量的示例。
理解synchronized关键字
synchronized关键字是Scala中用于实现线程同步的重要工具。它可以确保在同一时刻只有一个线程可以访问被synchronized保护的代码块或方法。这对于保护共享资源（例如变量）免受并发访问带来的数据竞争问题至关重要。
synchronized的作用范围：
synchronized可以用于修饰方法或代码块。
- synchronized方法： 当一个方法被synchronized修饰时，它会锁定该方法所属对象的monitor。这意味着，只有拥有该对象monitor的线程才能执行这个方法。
- synchronized代码块： synchronized代码块允许你指定一个对象作为monitor。只有拥有该对象monitor的线程才能执行该代码块。
注意事项：
- synchronized只能保证同一时刻只有一个线程访问被保护的代码，但它不能保证线程的执行顺序。线程的执行顺序仍然是不确定的，取决于操作系统的调度。
- 如果多个线程尝试访问同一个对象的synchronized方法或代码块，只有一个线程能够获得锁并执行，其他线程将被阻塞，直到锁被释放。
案例分析与问题解决
让我们分析一个常见的线程安全问题，并展示如何使用synchronized来解决它。
问题代码：
object Example {
def injectFunction(body: =>Unit): Thread = {
val t = new Thread {
override def run() = body
}
t
}
private var counter: Int = 0
def increaseCounter(): Unit = this.synchronized {
//putting this as synchronized doesn't work for some reason..
counter = counter + 1
counter
}
def printCounter(): Unit = {
println(counter)
}
def main(args: Array[String]): Unit = {
val t1: Thread = injectFunction(increaseCounter())
val t2: Thread = injectFunction(increaseCounter())
val t3: Thread = injectFunction(printCounter())
t1.start()
t2.start()
t3.start()
}
}这段代码尝试使用两个线程增加一个共享的计数器，然后使用第三个线程打印计数器的值。然而，由于线程的并发执行，打印的值往往不是预期的结果（通常是1，有时是0或2）。
问题分析：
- 线程执行顺序不确定： synchronized只保证了increaseCounter方法的原子性，但不能保证t3线程在t1和t2线程之后执行。
- println操作未同步： printCounter方法中的println操作没有被synchronized保护，因此t3线程可能在t1和t2线程修改counter的过程中读取到counter的值，导致打印出不一致的结果。
- 对象初始化问题： 原代码在object初始化阶段启动线程，可能导致死锁，因为线程可能尝试访问尚未完全初始化的对象。
解决方案：
import scala.util.Random
object Example {
def injectFunction(body: =>Unit): Thread = {
val t = new Thread {
override def run() = body
}
t
}
private var counter: Int = 0
def increaseCounter(): Unit = {
Thread.sleep(Random.nextInt(100)) // 模拟耗时操作
this.synchronized {
counter += 1
}
}
def printCounter(): Unit = {
Thread.sleep(Random.nextInt(100)) // 模拟耗时操作
println("Random state: " + this.synchronized { counter })
}
def main(args: Array[String]): Unit = {
val t1: Thread = injectFunction(increaseCounter())
val t2: Thread = injectFunction(increaseCounter())
val t3: Thread = injectFunction(printCounter())
t1.start()
t2.start()
t3.start()
t1.join() // 等待线程执行完成
t2.join() // 等待线程执行完成
t3.join() // 等待线程执行完成
println("Final state: " + counter)
}
}代码解释：
- 同步println操作： printCounter方法中的println操作现在也使用synchronized来保护，确保读取counter的值是原子性的。
- 模拟耗时操作： 在 increaseCounter 和 printCounter 中添加了 Thread.sleep，模拟实际场景中的耗时操作，增加并发冲突的可能性，更容易观察到线程安全问题。
- 使用join方法： 在main方法中使用t1.join()、t2.join()和t3.join()来等待所有线程执行完成，然后再打印最终的counter值，确保最终结果的正确性。
- 将所有操作放在main函数中 避免了在object初始化阶段启动线程可能导致的死锁。
运行结果：
现在，运行这段代码，你将会看到Random state的值可能是0、1或2，但Final state的值总是2，这表明synchronized成功地保证了线程安全。
总结
synchronized是Scala中实现线程同步的关键工具，但要正确使用它需要理解其作用范围和限制。在处理共享资源时，务必确保所有对共享资源的读写操作都受到synchronized的保护。此外，还要注意线程的执行顺序是不确定的，以及对象初始化可能导致的问题。通过合理使用synchronized，我们可以编写出线程安全、可靠的Scala多线程程序。
