本文想探讨的问题有两个：
- 如果我们在synchronized代码块中创建一个Future会发生什么？
- 如果我们在创建Future的代码块中加synchronized又会发生什么？
问题的本质是：
- 在同步代码块执行异步执行的代码块会发生什么？
- 在异步代码块中执行同步代码块又会发生什么？
为此，我们进行了实验。
首先是第一个问题：
import scala.concurrent._
import ExecutionContext.Implicits.global
import scala.concurrent.duration.Duration
import scala.util.{Failure, Success}
object FutureSynchronize {
def compute(x: Int, y: Int): Int = {
try {
x / y
} catch {
case e: Exception => throw e
}
}
def getFuture(x: Int, y: Int): Future[Int] = {
synchronized {
println(Thread.currentThread().getName + " get into synchronized")
println("we are sleeping, do not bother us.")
// Thread-0 will stuck on synchronized until Thread-main wake up.
Thread.sleep(5000)
val f = Future {
Thread.sleep(5000)
compute(x, y)
}
f.onComplete {
case Success(result) => println("Then, print future result: " + result)
case Failure(e) => println("Then, rint future exception: " + e)
}
println("return a Future without value")
f
}
}
def main(args: Array[String]): Unit = {
// Thread-main
val f1: Future[Int] = getFuture(5, 2)
var f2: Future[Int] = null
// Thread-0
new Thread(new Runnable {
override def run(): Unit = {
f2 = getFuture(6000, 200)
}
}).start()
Await.ready(f1, Duration.Inf)
Await.ready(f2, Duration.Inf)
}
}
实验证明，当我们在synchronized代码块中创建Future(以及定义onComplete函数)时，如果Thread-main先进入了synchronized代码块，Thread-0就会阻塞在synchronized处。但是，Future在创建完成之后还是会立即（不带结果）返回。同时，虽然在synchronized代码块中定义了onComplete函数，但是也不会立即执行。等到Future异步的计算完成，执行onComplete时，此时线程已经不在synchronized代码块内部了。
第二个问题：
package concurrent
import scala.concurrent._
import ExecutionContext.Implicits.global
import scala.concurrent.duration.Duration
import scala.util.{Failure, Success}
object FutureSynchronize {
def compute(x: Int, y: Int): Int = {
try {
x / y
} catch {
case e: Exception => throw e
}
}
def getFuture(x: Int, y: Int): Future[Int] = {
val f = Future {
synchronized {
println(Thread.currentThread().getName + " get into synchronized")
Thread.sleep(5000)
compute(x, y)
}
}
f.onComplete {
case Success(result) => println("Then, print future result: " + result)
case Failure(e) => println("Then, rint future exception: " + e)
}
println("return a Future without value")
f
}
def main(args: Array[String]): Unit = {
// Thread-main
val f1: Future[Int] = getFuture(5, 2)
var f2: Future[Int] = null
// Thread-0
new Thread(new Runnable {
override def run(): Unit = {
f2 = getFuture(6000, 200)
}
}).start()
Await.ready(f1, Duration.Inf)
Await.ready(f2, Duration.Inf)
}
}
实验证明，如果我们在创建Future的代码块内部加synchronized关键字，执行的效果和不加是一样的。这是因为在scala中，Future执行异步计算时的线程是由ExecutionContextImpl默认从线程池分配的。所以，在这里其实是在两个不同的线程内部各自加锁，所以不存在锁的竞争。当然，如果我们自定义了一个ExecutionContext, 且该ExecutionContext中只有一个可分配的线程，则会发生锁的竞争。则此时，只有当一个Future计算完成时，才能再计算下一个Future。在这里，我们讨论的是scala中的情形，但是在其它的异步代码执行时，应该也遵循同样的原理。
