泛函编程(20)-泛函库设计-Further Into Parallelism

  • 时间:
  • 浏览:5
  • 来源:彩神大发pk10_神彩大发pk10官方

再做个新的习题:用并行运算措施Filter List:

2. g: List[B] => B

1、lp: List[Par[B]] = l.map(asyncF(f))

亲戚亲戚朋友再看看现在所有的组件函数算不算足够应付所有问題,还需不都要增加以后 基本组件,这也是开发另十2个 多多函数库都要走的过程;这以后 我另十2个 多多不断更新的过程。

ppa: Par[Par[A]], 以后 run(es)(ppa).get 得到 pa: Par[A], 再run(es)(pa) >>> Future[A]。 Par[A] = es => Future[A],不就除理问題了嘛:

这两步可不后能 分另十2个 多多函数来实现:

2、pl: Par[List[B]] = sequence(lp) >>> parMap

这样flatMap,join,map之间有这样那先 数学关系呢?

 亲戚亲戚朋友还是从类型匹配着手一步步推导:

2、List(A,B,C) >>> A.size + B.size + C.size >>> 把List里的文字数积合。

3、pll: Par[List[List[A]]] = sequence(lpl)

    上两节亲戚亲戚朋友建了另十2个 多多并行运算组件库,实现了以后 基本的并行运算功能。到现在你是什么 阶段,编写并行运算函数以后 可不后能 和数学代数解题相近了:亲戚亲戚朋友了解了问題需求,以后 从类型匹配入手逐步产生题解。下面亲戚亲戚朋友再多做十2个 练习吧。

既然亲戚亲戚朋友能在另十2个 多多并行运算中取舍 ,这样能在N个并行运算中取舍 全部时会能更抽象吗?

2、lpl: List[Par[List[A]]] = as.map( asyncF( a => if(f(a)) List(a) else List()))

1、asyncF( a => if(f(a)) List(a) else List() )  >>> Par[List[A]]

相信亲戚亲戚朋友对泛函编程的你是什么 数学解题模式以后 有了一定的了解。

现在有个新问題:以后 另十2个 多多并行运算的运行依赖曾经并行运算的结果,应该何如除理?先看看问題的类型款式:

1、"the quick fox".split(' ').size >>> 把字符串分解成文字并计算数量

亲戚亲戚朋友可不后能 看了现在choice是个最基本组件了。为了除理另十2个 多多问題就创造另十2个 多多新的组件全部时会泛函编程的风格。应该是用以后 更基本的组件组合成另十2个 多多描述你是什么 问題的函数,那才是亲戚亲戚朋友要采用的风格。亲戚亲戚朋友应该试着用另十2个 多多函数能把Par[Par[A]]变成Par[A],以后 就可不后能 用map了:

再做另十2个 多多计算字数的练习:用并行运算措施来计算List里的文字数。亲戚亲戚朋友尽量用共性的措施来通用化解答。以后 文字是以List装载的活,类型以后 我:List[String],举个实例:List("the quick fox","is running","so fast")。亲戚亲戚朋友可不后能 分两步除理:

在前面亲戚亲戚朋友无法用map来实现choice,以后 类型不匹配。加了另十2个 多多join函数,又以后 map元素类型不匹配,又不行。现在看来flatMap恰恰是亲戚亲戚朋友都要除理choice的组件,以后 flatMap能更抽象一层,连choiceN都一并除理了。值得注意的是亲戚亲戚朋友在以上除理问題的过程中一再提及类型匹配,这恰恰体现了泛函编程以后 我函数解题的过程。

在前面亲戚亲戚朋友曾经提过现在的fork实现措施以后 使用固定数量应用程序池一段话有以后 造成锁死:

1. f: A => B >>> 亲戚亲戚朋友都要把你是什么 函数转成并行运算:List[Par[B]]

可不后能 看出亲戚亲戚朋友提交的callable结构是另十2个 多多run par,你是什么 run会再提交另十2个 多多callable以后 锁定get。外面的callable都要等待结构callable的get锁定完成。以后 你是什么 fork实现是都要另十2个 多多应用程序的。以后 应用程序池无法再为结构callable提供应用程序一段话,这样外面的callable就会指在永远等待中形成死锁。后边的parMap函数会按照List的长度分解出同等数量的并行运算,运行时会造成死锁吗?以后 应用程序池全部时会固定数量应用程序一段话,答案以后 我否定的:以后 并行运算数量大于应用程序数,这样运算会分批进行:后边的运算可不后能 等待前面的运算完成后释放出应用程序后继续运行,这里重点是前面的运算始终是可不后能 完成的,以后 不要再造成死锁。

在上节亲戚亲戚朋友介绍了asyncF,它的类型款式是曾经的:asyncF(f: A => B): A => Par[B],从类型款式(type signature)分析,asyncF函数的功能是把另十2个 多多普通的函数 A => B转成A => Par[B],Par[B]是另十2个 多多并行运算。也以后 我说asyncF可不后能 把另十2个 多多输入参数A的函数变成另十2个 多多同样输入参数A的并行运算。asyncF函数可不后能 把List[A],一串A值,按照函数A => B变成List[Par[A]],即一串并行运算。

4、map(pll){ a => a.flatten } >>> Par[List{A]]

现在可不后能 用map来实现choice了吧。以后 ,map是针对元素A来操作的,ifTrue和ifFalse全部时会Par[A],还无法使用map。那就先放放吧。

例:函数f: (a: A) => a + 10:List(1,2,3).map(asyncF(f))=List(Par(1+10),Par(2+10),Par(3+10)),那先 Par是并行运算的。但它们的运算结果都要曾经函数sequence来读取。亲戚亲戚朋友从以上分析可不后能 得出sequence的类型款式:

parMap按List[A]产生了一串并行运算的函数f。亲戚亲戚朋友可不后能 从类型匹配着手一步一步推导: