我们在上一节讨论了scalaz Future,我们说它是一个不完善的类型,最起码没有完整的异常处理机制,只能用在构建类库之类的内部环境。如果scalaz在Future类定义中增加异常处理工具的话,用户就会经常遇到Future[Throwable\/A]这样的类型,那么在进行Monadic编程时就必须使用Monad Transformer来匹配类型,程序就会变得不必要的复杂。scalaz的解决方案就是把Future[Throwable\/A]包嵌在Task类里,然后把所有Future都统一升格成Task。Task是个Monad, 这样,我们就可以统一方便地用Task来进行多线程函数式编程了。我们先看看Task的定义:scalaz.concurrent/Task.scala

class Task[+A](val get: Future[Throwable \/ A]) {

  def flatMap[B](f: A => Task[B]): Task[B] =
new Task(get flatMap {
case -\/(e) => Future.now(-\/(e))
case \/-(a) => Task.Try(f(a)) match {
case e @ -\/(_) => Future.now(e)
case \/-(task) => task.get
}
}) def map[B](f: A => B): Task[B] =
new Task(get map { _ flatMap {a => Task.Try(f(a))} })
...

Task实现了flatMap,所以是个Monad,我们可以在for-comprehension中使用Task。

Task的构建方式与Future一样:

 val tnow = Task.now { println("run now ..."); + }
//> run now ...
//| tnow : scalaz.concurrent.Task[Int] = scalaz.concurrent.Task@1a968a59
val tdelay = Task.delay { println("run delay ..."); + }
//> tdelay : scalaz.concurrent.Task[Int] = scalaz.concurrent.Task@13deb50e
val tapply = Task { println("run apply ..."); + }
//> tapply : scalaz.concurrent.Task[Int] = scalaz.concurrent.Task@59494225

同样,now函数是即时运算的。它就是一个lifter,能把一个普通运算直接升格为Task。

针对Task有几种运算方法:

 tnow.unsafePerformSync                            //> res0: Int = 7
tdelay.unsafePerformSync //> run delay ...
//| res1: Int = 7
tnow.unsafePerformAsync {
case \/-(a) => println(s"the result is: $a")
case -\/(e) => println(e.getMessage)
} //> the result is: 7
tdelay.unsafePerformAsync {
case \/-(a) => println(s"the result is: $a")
case -\/(e) => println(e.getMessage)
} //> run delay ...
//| the result is: 7
tapply.unsafePerformAsync {
case \/-(a) => println(s"the result is: $a")
case -\/(e) => println(e.getMessage)
}
Thread.sleep() //> run apply ...
//| the result is: 7

从上面的例子我们可以得出:tnow已经完成了运算,因为运算结果没有"run now ..."提示了。tdelay和tapply都是存在trampoline结构里的。但tapply存在更深一层的结构里,所以我们必须拖时间来等待tapply的运算结果。tdelay存放在Future.Suspend结构里,而tapply是存放在Future.Async结构里的,所以tdelay是一种延迟运算,而tapply就是异步运算了:

 def delay[A](a: => A): Task[A] = suspend(now(a))
def suspend[A](a: => Task[A]): Task[A] = new Task(Future.suspend(
Try(a.get) match {
case -\/(e) => Future.now(-\/(e))
case \/-(f) => f
}))
//Future.suspend:
def suspend[A](f: => Future[A]): Future[A] = Suspend(() => f) def apply[A](a: => A)(implicit pool: ExecutorService = Strategy.DefaultExecutorService): Task[A] =
new Task(Future(Try(a))(pool))
//Future.apply
def apply[A](a: => A)(implicit pool: ExecutorService = Strategy.DefaultExecutorService): Future[A] = Async { cb =>
pool.submit { new Callable[Unit] { def call = cb(a).run }}
}

好了,我们再看看Task是怎样处理异常情况的:

 def eval(value: => Int) = Task { Thread.sleep(); value }
//> eval: (value: => Int)scalaz.concurrent.Task[Int]
eval( * ).onFinish {
case None => Task { println("finished calculation successfully.") }
case Some(e) => Task { println(s"caught error [${e.getMessage}]") }
}.unsafePerformSyncAttempt match {
case -\/(e) => println(s"calculation error [${e.getMessage}]")
case \/-(a) => println(s"the result is: $a")
} //> finished calculation successfully.
//| the result is: 21
// 异常处理
eval( * / ).onFinish {
case None => Task { println("finished calculation successfully.") }
case Some(e) => Task { println(s"caught error [${e.getMessage}]") }
}.unsafePerformAsync {
case -\/(e) => println(s"calculation error [${e.getMessage}]")
case \/-(a) => println(s"the result is: $a")
}
Thread.sleep() //> caught error [/ by zero]
//| calculation error [/ by zero]

精准异常处理例子:

 import java.util.concurrent._
val timedTask = Task {Thread.sleep(); +}
//> timedTask : scalaz.concurrent.Task[Int] = scalaz.concurrent.Task@3d921e20
timedTask.timed( second).handleWith {
case e: TimeoutException => Task { println(s"calculation exceeding time limit: ${e.getMessage}") }
}.unsafePerformSync //> calculation exceeding time limit: Timed out after 1000 milliseconds
//| res2: AnyVal{def getClass(): Class[_ >: Int with Unit <: AnyVal]} = ()

再看一些多线程编程例子:

 val tasks = ( |-> ).map(n => Task{ Thread.sleep(); n })
//> tasks : List[scalaz.concurrent.Task[Int]] = List(scalaz.concurrent.Task@61
//| 8b19ad, scalaz.concurrent.Task@2d3379b4, scalaz.concurrent.Task@30c15d8b, s
//| calaz.concurrent.Task@5e0e82ae, scalaz.concurrent.Task@6771beb3)
//并行运算list of tasks
Task.gatherUnordered(tasks).unsafePerformSync //> res3: List[Int] = List(1, 2, 3, 4, 5)
val sb = new StringBuffer //> sb : StringBuffer =
val t1 = Task.fork { Thread.sleep(); sb.append("a"); Task.now("a")}
//> t1 : scalaz.concurrent.Task[String] = scalaz.concurrent.Task@6200f9cb
val t2 = Task.fork { Thread.sleep(); sb.append("b"); Task.now("b")}
//> t2 : scalaz.concurrent.Task[String] = scalaz.concurrent.Task@2002fc1d
val t3 = Task.fork { Thread.sleep(); sb.append("c"); Task.now("c")}
//> t3 : scalaz.concurrent.Task[String] = scalaz.concurrent.Task@69453e37
val t4 = Task.fork { Thread.sleep(); sb.append("d"); Task.now("d")}
//> t4 : scalaz.concurrent.Task[String] = scalaz.concurrent.Task@6f4a47c7
val t5 = Task.fork { Thread.sleep(); sb.append("e"); Task.now("e")}
//> t5 : scalaz.concurrent.Task[String] = scalaz.concurrent.Task@ae13544
val t6 = Task.fork { Thread.sleep(); sb.append("f"); Task.now("f")}
//> t6 : scalaz.concurrent.Task[String] = scalaz.concurrent.Task@3d34d211
val r = Nondeterminism[Task].nmap6(t1,t2,t3,t4,t5,t6)(List(_,_,_,_,_,_))
//> r : scalaz.concurrent.Task[List[String]] = scalaz.concurrent.Task@394df057
r.unsafePerformSync //> res4: List[String] = List(a, b, c, d, e, f)

看个耗时算法的并行运算吧:

 def seqFib(n: Int): Task[Int] =  n match {
case | => Task now
case n => {
for {
x <- seqFib(n-)
y <- seqFib(n-)
} yield x + y
}
} //> seqFib: (n: Int)scalaz.concurrent.Task[Int]
//并行算法
def parFib(n: Int): Task[Int] = n match {
case | => Task now
case n => {
val ND = Nondeterminism[Task]
for {
pair <- ND.both(parFib(n-), parFib(n-))
(x,y) = pair
} yield x + y
}
} //> parFib: (n: Int)scalaz.concurrent.Task[Int]
def msFib(n: Int, fib: Int => Task[Int]) = for {
b <- Task now { System.currentTimeMillis() }
a <- fib(n)
e <- Task now { System.currentTimeMillis() }
} yield (a, (e-b)) //> msFib: (n: Int, fib: Int => scalaz.concurrent.Task[Int])scalaz.concurrent.T
//| ask[(Int, Long)] msFib(, parFib).unsafePerformSync //> res3: (Int, Long) = (10946,373)
msFib(, seqFib).unsafePerformSync //> res4: (Int, Long) = (10946,17)

哎呀!奇怪了,为什么并行算法要慢很多呢?这个问题暂且放一放,以后再研究。当然,如果有读者能给出个解释就太感激了。
Task的线程池是如何分配的呢?看看Task.apply和Task.fork:

 /** Create a `Task` that will evaluate `a` using the given `ExecutorService`. */
def apply[A](a: => A)(implicit pool: ExecutorService = Strategy.DefaultExecutorService): Task[A] =
new Task(Future(Try(a))(pool))
def fork[A](a: => Task[A])(implicit pool: ExecutorService = Strategy.DefaultExecutorService): Task[A] =
apply(a).join
//Future.apply
/** Create a `Future` that will evaluate `a` using the given `ExecutorService`. */
def apply[A](a: => A)(implicit pool: ExecutorService = Strategy.DefaultExecutorService): Future[A] = Async { cb =>
pool.submit { new Callable[Unit] { def call = cb(a).run }}

这两个函数都包括了一个隐式参数implicit pool: ExecutorService。默认值是Strategy.DefultExecutorService。我们可以这样指定线程池:

  Task {longProcess}(myExecutorService)
Task.fork { Task {longProcess} }(myExecutorService)

下面是一个动态指定线程池的例子:

 import java.util.concurrent.{ExecutorService,Executors}
type Delegated[A] = Kleisli[Task,ExecutorService,A]
def delegate: Delegated[ExecutorService] = Kleisli(e => Task.now(e))
//> delegate: => demo.ws.task.Delegated[java.util.concurrent.ExecutorService]
implicit def delegateTaskToPool[A](ta: Task[A]): Delegated[A] = Kleisli(x => ta)
//> delegateTaskToPool: [A](ta: scalaz.concurrent.Task[A])demo.ws.task.Delegated[A]
val tPrg = for {
p <- delegate
b <- Task("x")(p)
c <- Task("y")(p)
} yield c //> tPrg : scalaz.Kleisli[scalaz.concurrent.Task,java.util.concurrent.Executor
//| Service,String] = Kleisli(<function1>)
tPrg.run(Executors.newFixedThreadPool()).unsafePerformSync
//> res3: String = y

当然,Task和scala Future之间是可以相互转换的:

 import scala.concurrent.{Future => sFuture}
import scala.util.{Success,Failure}
import scala.concurrent.ExecutionContext
def futureToTask[A](fut: sFuture[A])(implicit ec: ExecutionContext): Task[A] =
Task.async {
cb =>
fut.onComplete {
case Success(a) => cb(a.right)
case Failure(e) => cb(e.left)
}
}
def taskToFuture[A](ta: Task[A]): sFuture[A] = {
val prom = scala.concurrent.Promise[A]
ta.unsafePerformAsync {
case -\/(e) => prom.failure(e)
case \/-(a) => prom.success(a)
}
prom.future
}

与Future不同的是:Task增加了异常处理机制。

Scalaz(45)- concurrency :Task-函数式多线程编程核心配件的更多相关文章

  1. Scalaz(54)- scalaz-stream: 函数式多线程编程模式-Free Streaming Programming Model

    长久以来,函数式编程模式都被认为是一种学术研究用或教学实验用的编程模式.直到近几年由于大数据和多核CPU的兴起造成了函数式编程模式在一些实际大型应用中的出现,这才逐渐改变了人们对函数式编程无用论的观点 ...

  2. Java多线程编程核心(1)

    Java多线程编程核心(1) 停止线程 本节主要讨论如何更好停止一个线程.停止线程意味着在线程处理完成任务之前放弃当前操作. 1.停不了的线程 可能大多数同学会使用interrupt()来停止线程,但 ...

  3. Task+ConcurrentQueue多线程编程

    队列(Queue)代表了一个先进先出的对象集合.当您需要对各项进行先进先出的访问时,则使用队列.当您在列表中添加一项,称为入队,当您从列表中移除一项时,称为出队. ConcurrentQueue< ...

  4. (1)Java多线程编程核心——Java多线程技能

    1.为什么要使用多线程?多线程的优点? 提高CPU的利用率 2.什么是多线程? 3.Java实现多线程编程的两种方式? a.继承Thread类 public class MyThread01 exte ...

  5. Java多线程编程核心 - 对象及变量的并发访问

    1.什么是“线程安全”与“非线程安全”? “非线程安全”会在多个线程对同一对象总的实例变量进行并发访问时发生,产生的后果是“脏读”,也就是取到的数据其实是被更改过的. “线程安全”是以获得的实例变量的 ...

  6. Java多线程编程实战指南(核心篇)读书笔记(五)

    (尊重劳动成果,转载请注明出处:http://blog.csdn.net/qq_25827845/article/details/76730459冷血之心的博客) 博主准备恶补一番Java高并发编程相 ...

  7. Java多线程编程实战指南(核心篇)读书笔记(四)

    (尊重劳动成果,转载请注明出处:http://blog.csdn.net/qq_25827845/article/details/76690961冷血之心的博客) 博主准备恶补一番Java高并发编程相 ...

  8. 5天玩转C#并行和多线程编程 —— 第四天 Task进阶

    5天玩转C#并行和多线程编程系列文章目录 5天玩转C#并行和多线程编程 —— 第一天 认识Parallel 5天玩转C#并行和多线程编程 —— 第二天 并行集合和PLinq 5天玩转C#并行和多线程编 ...

  9. 5天玩转C#并行和多线程编程 —— 第三天 认识和使用Task

    5天玩转C#并行和多线程编程系列文章目录 5天玩转C#并行和多线程编程 —— 第一天 认识Parallel 5天玩转C#并行和多线程编程 —— 第二天 并行集合和PLinq 5天玩转C#并行和多线程编 ...

随机推荐

  1. Atitit 编程语言原理与概论attilax总结 三大书籍总结

    Atitit 编程语言原理与概论attilax总结 三大书籍总结 编程语言原理(第10版) 目录: 第1章 预备知识第2章 主要程序设计语言的发展第3章 描述语法和语义第4章 词法分析和语法分析第5章 ...

  2. 转:Acegi Security

    Acegi Security -- Spring下最优秀的安全系统 http://www.springside.org.cn/docs/reference/Acegi.htm 1. Acegi 介绍 ...

  3. 学习Data Science/Deep Learning的一些材料

    原文发布于我的微信公众号: GeekArtT. 从CFA到如今的Data Science/Deep Learning的学习已经有一年的时间了.期间经历了自我的兴趣.擅长事务的探索和试验,有放弃了的项目 ...

  4. ssh(sturts2_spring_hibernate) 框架搭建之hibernate2

    一.今天要进行解答的是对上次hibernate1进行进一步的完善,这次第一是进一步使用spring注入一个SessionFactory实例,避免了自己new实例:第二是应用数据库池(c3p0). 二. ...

  5. SQL Pass北京举行2014年第一次线下活动

    地点:北京微软(中国)有限公司[望京利星行],三层308室 时间:2014年 3 月15日 13:30-16:30 SQL PASS 北京QQ群号:2435349 报名地址:http://1drv.m ...

  6. poj 2187 Beauty Contest(凸包求解多节点的之间的最大距离)

    /* poj 2187 Beauty Contest 凸包:寻找每两点之间距离的最大值 这个最大值一定是在凸包的边缘上的! 求凸包的算法: Andrew算法! */ #include<iostr ...

  7. [OpenCV] Samples 02: [ML] kmeans

    注意Mat作为kmeans的参数的含义. 扩展:高维向量的聚类. #include "opencv2/highgui.hpp" #include "opencv2/cor ...

  8. weback学习笔记

    weback可以把各种资源,例如JS(含JSX).coffee.样式(含less/sass).图片等都作为模块来使用和处理.同时支持amd cmd CommonJS语法.同时可以和gulp一块使用. ...

  9. Linux下通过源码编译安装程序

    本文简单的记录了下,在linux下如何通过源码安装程序,以及相关的知识.(大神勿喷^_^) 一.程序的组成部分 Linux下程序大都是由以下几部分组成: 二进制文件:也就是可以运行的程序文件 库文件: ...

  10. C#抓取天气数据

    使用C#写的一个抓取天气数据的小工具,使用正则匹配的方式实现,代码水平有限,供有需要的同学参考.压缩包中的两个sql语句是建表用的. http://files.cnblogs.com/files/yu ...