Scala之Future

package base.day06.future

import scala.concurrent.{ExecutionContext, Future}
import scala.util.{Failure, Success}

/**
  * @description FutureDriver
  * @author ZerlindaLi create at 2019/5/8 15:50
  * @version 1.0.0
  */
object FutureDriver {
  implicit val ec = ExecutionContext.global
  def main(args: Array[String]): Unit = {

    // 分别定义执行了3个线程f1,f2,f3
    val f1 = Future[Unit] {
      for (i <- 1 to 50) {
        println("f1:"+i)
      }
    }

    val f2 = Future{
      for (i <- 1 to 50) {
        println("f2:"+i)
      }
    }

    val f3 = Future{
      for (i <- 1 to 50) {
        println("f3:"+i)
      }
    }

    // 线程f4等f1,f2,f3执行完毕后之后，yield代码块里面的内容为f4线程执行的代码
    val f4 = for{
      list1 <- f1
      list2 <- f2
      list3 <- f3
    }yield{
      println(list1)
      println(list2)
      println(list3)
      for (i <- 1 to 50) {
        println("f4:"+i)
      }
    }

    // 回调，成功和失败两种结果
    f4.onComplete{
      case Success(e) => println("success")
      case Failure(t) => println("Failure")
    }

    println()
    println("f1 之後")

    // 主线程结束后，控制台会停掉，看不到子线程打印内容，所以这里沉睡10s.
    Thread.sleep(10000)
  }

}

以上为Scala的Future的基本用法，它还有函数组合的功能

    override def foreach[U](f: Nothing => U)(implicit executor: ExecutionContext): Unit = ()
    override def transform[S](s: Nothing => S, f: Throwable => Throwable)(implicit executor: ExecutionContext): Future[S] = this
    override def transform[S](f: Try[Nothing] => Try[S])(implicit executor: ExecutionContext): Future[S] = this
    override def transformWith[S](f: Try[Nothing] => Future[S])(implicit executor: ExecutionContext): Future[S] = this
    override def map[S](f: Nothing => S)(implicit executor: ExecutionContext): Future[S] = this
    override def flatMap[S](f: Nothing => Future[S])(implicit executor: ExecutionContext): Future[S] = this
    override def flatten[S](implicit ev: Nothing <:< Future[S]): Future[S] = this
    override def filter(p: Nothing => Boolean)(implicit executor: ExecutionContext): Future[Nothing] = this
    override def collect[S](pf: PartialFunction[Nothing, S])(implicit executor: ExecutionContext): Future[S] = this
    override def recover[U >: Nothing](pf: PartialFunction[Throwable, U])(implicit executor: ExecutionContext): Future[U] = this
    override def recoverWith[U >: Nothing](pf: PartialFunction[Throwable, Future[U]])(implicit executor: ExecutionContext): Future[U] = this
    override def zip[U](that: Future[U]): Future[(Nothing, U)] = this
    override def zipWith[U, R](that: Future[U])(f: (Nothing, U) => R)(implicit executor: ExecutionContext): Future[R] = this
    override def fallbackTo[U >: Nothing](that: Future[U]): Future[U] = this
    override def mapTo[S](implicit tag: ClassTag[S]): Future[S] = this
    override def andThen[U](pf: PartialFunction[Try[Nothing], U])(implicit executor: ExecutionContext): Future[Nothing] = this

Transforming Futures with map

map会等待原来的Future执行完毕，将原来的Future的结果进行操作，会返回一个新的Future
代码例子如下

    val fut = Future {
      Thread.sleep(3000);
      21 + 21
    }

    fut.map(x=>x+1).onComplete{
      case Success(s) => println("fut success:"+s)
      case Failure(e) => println("fut failure:"+e)
    }

这个的运行结果是

fut success:43

Transforming Futures with for expressions

for {}yeild{}是在for中将其他多个Future赋值，等待他们执行完毕之后，再执行yield这个新的Future.

    val fut1 = Future {
      Thread.sleep(1000);
      21 + 21
    }

    val fut2 = Future {
      Thread.sleep(1000);
      23 + 23
    }

    val res3 = for {
      x <- fut1
      y <- fut2
    } yield x + y

    res3.map(x=>x+1).onComplete{
      case Success(s) => println("res3 success:"+s)
      case Failure(e) => println("res3 failure:"+e)
    }

执行结果

res3 success:89

上面的代买在缩写一下…

    (for {
      x <- Future {
        Thread.sleep(1000);
        21 + 21
      }
      y <- Future {
        Thread.sleep(1000);
        21 + 21
      }
    } yield {x + y}).onComplete{
      case Success(s) => println("res4 success:"+s)
      case Failure(e) => println("res4 failure:"+e)
    }

Creating the Future: Future.failed, Future.successful, Future.fromTry, and Promises

我们在第一段代码中可以看到这样一句话

implicit val ec = ExecutionContext.global

这个是定义隐式的执行上下文来执行Future. 以下这些方式来创建Future不需要用到ExecutionContext

package base.day06.future

import scala.concurrent.Future
import scala.util.{Failure, Success}

object FutureConstructDriver {

  def main(args: Array[String]): Unit = {
    println(Future.successful { Thread.sleep(1000);21 + 21 })

    println(Future.failed(new Exception("Bummer!")))

    println(Future.fromTry(Success{21+21}))

    println(Future.fromTry(Failure(new Exception("Bummer!"))))
  }
}

执行结果如下

Future(Success(42))
Future(Failure(java.lang.Exception: Bummer!))
Future(Success(42))
Future(Failure(java.lang.Exception: Bummer!))

使用promise是最常见的创建Future的方式

    // 使用promise得到一个Future,这个Future由promise来控制。当promise完成时，这个future才会完成
    println("======= Promise[Int] ============")
    val pro = Promise[Int]
    val fut = pro.future
    println("pro:"+pro)
    println("fut:"+fut)

    // 通过success, failure, complete来完成promise.
    println("======= pro.success(42) ============")
    pro.success(42)
    println("pro : "+pro)
    println("fut : "+fut)

执行结果

======= Promise[Int] ============
pro:Future()
fut:Future()
======= pro.success(42) ============
pro : Future(Success(42))
fut : Future(Success(42))

Filtering: filter and collect

future提供了filter和collect两个过滤方法

参考文档

https://docs.scala-lang.org/zh-cn/overviews/core/futures.html#函数组合functional-composition和for解构for-comprehensions
《Programming in Scala, 3rd Edition》