BlogJava-庄周梦蝶-随笔分类-动态语言

详解Clojure的递归(上）—— 直接递归及优化

dennis — Wed, 14 Jul 2010 14:03:00 GMT

    详解clojure递归（上）
    详解clojure递归（下）

    递归可以说是LISP的灵魂之一，通过递归可以简洁地描述数学公式、函数调用，Clojure是LISP的方言，同样需要递归来扮演重要作用。递归的价值在于可以让你的思维以what的形式思考，而无需考虑how，你写出来的代码就是数学公式，就是函数的描述，一切显得直观和透明。如果你不习惯递归，那只是因为命令式语言的思维根深蒂固，如x=x+1这样的表达式，从数学的角度来看完全不合法，但是在命令式语言里却是合法的赋值语句。

   递归可以分为直接递归和间接递归，取决于函数是否直接或者间接地调用自身。如果函数的最后一个调用是递归调用，那么这样的递归调用称为尾递归，针对此类递归调用，编译器可以作所谓的尾递归优化（TCO），因为递归调用是最后一个，因此函数的局部变量等没有必要再保存，本次调用的结果可以完全作为参数传递给下一个递归调用，清空当前的栈并复用，那么就不需要为递归的函数调用保存一长串的栈，因此不会有栈溢出的问题。在Erlang、LISP这样的FP语言里，都支持TCO，无论是直接递归或者间接递归。

   但是由于JVM自身的限制，Clojure和Scala一样，仅支持直接的尾递归优化，将尾递归调用优化成循环语句。例如一个求阶乘的例子：

;;第一个版本的阶乘函数
(defn fac [n]
          (if (= 1 n)
              1
             (* n (fac (dec n)))))

第一个版本的阶乘并非尾递归，这是因为最后一个表达式的调用是一个乘法运算，而非(fac (dec n))，因此这个版本的阶乘在计算大数的时候会导致栈溢出：

user=> (fac 10000)
java.lang.StackOverflowError (NO_SOURCE_FILE:0)

将第一个版本改进一下，为了让最后一个调用是递归调用，那么我们需要将结果作为参数来传递，而不是倚靠栈来保存，并且为了维持接口一样，我们引入了一个内部函数fac0：

;;第二个版本，不是尾递归的“尾递归”
(defn fac [n]
           (defn fac0 [c r]
              (if (= 0 c)
                  r
                  (fac0 (dec c) (* c r))))
           (fac0 n 1))

这个是第二个版本的阶乘，通过将结果提取成参数来传递，就将fac0函数的递归调用修改为尾递归的形式，这是个尾递归吗？这在Scala里，在LISP里，这都是尾递归，但是Clojure的TCO优化却是要求使用recur这个特殊形式，而不能直接用函数名作递归调用，因此我们这个第二版本在计算大数的时候仍然将栈溢出：

user=> (fac 10000)
java.lang.StackOverflowError (NO_SOURCE_FILE:0)

在Clojure里正确地TCO应该是什么样子的呢？其实只要用recur在最后调用那一下替代fac0即可，这就形成我们第三个版本的阶乘：

  ;;第三个版本，TCO起作用了
  (defn fac [n]
           (defn fac0 [c r]
              (if (= 0 c)
                  r
                  (recur (dec c) (* c r))))
           (fac0 n 1))

    此时你再计算大数就没有问题了，计算(fac 10000)可以正常运行（结果太长，我就不贴出来了）。recur只能跟函数或者loop结合在一起使用，只有函数和loop会形成递归点。我们第三个版本就是利用函数fac0做了尾递归调用的优化。

    loop跟let相似，只不过loop会在顶层形成一个递归点，以便recur重新绑定参数，使用loop改写阶乘函数，这时候就不需要定义内部函数了：

;;利用loop改写的第四个版本的阶乘函数
(defn fac [n]
           (loop [n n r 1]
                (if (= n 0)
                    r
                    (recur (dec n) (* n r)))))

   loop初始的时候将n绑定为传入的参数n（由于作用域不同，同名没有问题），将r绑定为1，最后recur就可以将新的参数值绑定到loop的参数列表并递归调用。

   Clojure的TCO是怎么做到的，具体可以看看我前两天写的这篇博客，本质上是在编译的时候将最后的递归调用转化成一条goto语句跳转到开始的Label，也就是转变成了循环调用。

   这个阶乘函数仍然有优化的空间，可以看到，每次计算其实都有部分是重复计算的，如计算(fac 5)也就是1*2*3*4*5，计算(fac 6)的1*2*3*4*5*6，如果能将前面的计算结果缓存下来，那么计算(fac 6)的时候将更快一些，这可以通过memoize函数来包装阶乘函数：

;;第五个版本的阶乘,缓存中间结果
(def fac (memoize fac))

第一次计算(fac 10000)花费的时间长一些，因为还没有缓存：

user=> (time (fac 10000))
"Elapsed time: 170.489622 msecs"

第二次计算快了非常多（其实没有计算，只是返回缓存结果）：

user=> (time (fac 10000))
"Elapsed time: 0.058737 msecs"

可以看到，如果没有预先缓存，利用memoize包装的阶乘函数也是快不了。memoize的问题在于，计算(fac n)路径上的没有用到的值都不会缓存，它只缓存最终的结果，因此如果计算n前面的其他没有计算过的数字，仍然需要重新计算。那么怎么保存路径上的值呢？这可以将求阶乘转化成另一个等价问题来解决。
我们可以将所有的阶乘结果组织成一个无穷集合，求阶乘变成从这个集合里取第n个元素，这是利用Clojure里集合是lazy的特性，集合里的元素如果没有使用到，那么就不会预先计算，而是等待要用到的时候才计算出来，定义一个阶乘结果的无穷集合，可以利用map将fac作用在整数集合上,map、reduce这样的高阶函数返回的是LazySeq：

(def fac-seq (map fac (iterate inc 0)))

(iterate inc 0)定义了正整数集合包括0，0的阶乘没有意义。这个集合的第0项其实是多余的。
查看fac-seq的类型，这是一个LazySeq:

user=> (class fac-seq)
clojure.lang.LazySeq

求n的阶乘，等价于从这个集合里取第n个元素：

user=> (nth fac-seq 10)
3628800

这个集合会比较耗内存，因为会缓存所有计算路径上的独立的值，哪怕他们暂时不会被用到。但是这种采用LazySeq的方式来定义阶乘函数的方式有个优点，那就是在定义fac-seq使用的fac函数无需一定是符合TCO的函数，我们的第一个版本的阶乘函数稍微修改下也可以使用，并且不会栈溢出：

(defn fac [n]
          (if (<= n 1)
              1
              (* n (fac (dec n)))))

(def fac (memoize fac))
(def fac-seq (map fac (iterate inc 0)))
(nth fac-seq 10000)

因为集合从0开始，因此只是修改了fac的if条件为n<=1的时候返回1。至于为什么这样就不会栈溢出，有兴趣的朋友可以自己思考下。

从这个例子也可以看出，一些无法TCO的递归调用可以转化为LazySeq来处理，这算是弥补JVM缺陷的一个办法。

dennis 2010-07-14 22:03 发表评论

Clojure的并发（一） Ref和STM

dennis — Tue, 13 Jul 2010 18:34:00 GMT

Clojure 的并发（一） Ref和STM
Clojure 的并发（二）Write Skew分析
Clojure 的并发（三）Atom、缓存和性能
Clojure 的并发（四）Agent深入分析和Actor
Clojure 的并发（五）binding和let
Clojure的并发（六）Agent可以改进的地方
Clojure的并发（七）pmap、pvalues和pcalls
Clojure的并发（八）future、promise和线程

    Clojure处理并发的思路与众不同，采用的是所谓STM的模型——软事务内存。你可以将STM想象成数据库，只不过是内存型的，它只支持事务的ACI，也就是原子性、一致性、隔离性，但是不包括持久性，因为状态的保存都在内存里。

    Clojure的并发API分为四种模型：
1、管理协作式、同步修改可变状态的Ref
2、管理非协作式、同步修改可变状态的Atom
3、管理异步修改可变状态的Agent
4、管理Thread local变量的Var。

    下面将对这四部分作更详细的介绍。

一、Ref和STM

1、ref:

通过ref函数创建一个可变的引用(reference)，指向一个不可变的对象：

(ref x)

例子：创建一个歌曲集合：

(def song (ref #{}))

2、deref和@:
取引用的内容，解引用使用deref函数

(deref song)

也可以用reader宏@：

@song

3、ref-set和dosync:

改变引用指向的内容，使用ref-set函数

(ref-set ref new-value)

如，我们设置新的歌曲集合，加入一首歌：

(ref-set song #{"Dangerous"})

但是这样会报错：

java.lang.IllegalStateException: No transaction running (NO_SOURCE_FILE:0)

这是因为引用是可变的，对状态的更新需要进行保护，传统语言的话可能采用锁，Clojure是采用事务，将更新包装到事务里，这是通过dosync实现的：

(dosync (ref-set song #{"Dangerous"}))

dosync的参数接受多个表达式，这些表达式将被包装在一个事务里，事务支持ACI：
（1）Atomic，如果你在事务里更新多个Ref，那么这些更新对事务外部来说是一个独立的操作。
（2）Consistent，Ref的更新可以设置 validator，如果某个验证失败，整个事务将回滚。
（3）Isolated，运行中的事务无法看到其他事务部分完成的结果。

dosync更新多个Ref，假设我们还有个演唱者Ref，同时更新歌曲集合和演唱者集合:

(def singer (ref #{}))
(dosync (ref-set song #{"Dangerous"})
               (ref-set singer #{"MJ"}) )

@song      =>  #{"Dangerous"}
@singer    =>  #{"MJ"}

4、alter:
完全更新整个引用的值还是比较少见，更常见的更新是根据当前状态更新，例如我们向歌曲集合添加一个歌曲，步骤大概是先查询集合内容，然后往集合里添加歌曲，然后更新整个集合：

(dosync (ref-set song (conj @song "heal the world")))

查询并更新的操作可以合成一步，这是通过alter函数：

(alter ref update-fn & args)

alter接收一个更新的函数，函数将在更新的时候调用，传入当前状态值并返回新的状态值，因此上面的例子可以改写为：

(dosync (alter song conj "heal the world"))

这里使用conj而非cons是因为conj接收的第一个参数是集合，也就是当前状态值，而cons要求第一个参数是将要加入的元素。

5、commute：
commute函数是alter的变形，commute顾名思义就是要求update-function是可交换的，它的顺序是可以任意排序。commute的允许的并发程度比alter更高一些，因此性能会更好。但是由于commute要求update-function是可交换的，并且会自动重排序，因此如果你的更新要求顺序性，那么commute是不能接受的,commute仅可用在对顺序性没有要求或者要求很低的场景：例如更新聊天窗口的聊天信息，由于网络延迟的因素和个人介入的因素，聊天信息可以认为是天然排序，因此使用commute还可以接受，更新乱序的可能性很低。
另一个例子就不能使用commute了，如实现一个计数器：

(def counter (ref 0))

实现一个next-counter函数获取计数器的下一个值，我们先使用commute实现：

(defn next-counter [] (dosync (commute counter inc)))

这个函数很简单，每次调用inc递增counter的值，接下来写个测试用例：启动50个线程并发去获取next counter:

(dotimes [_ 50] (.start (Thread. #(println (next-counter)))))

这段代码稍微解释下，dotimes是重复执行50次，每次启动new并启动一个Thread,这个Thread里干了两件事情：调用next-counter，打印调用结果,第一个版本的next-counter执行下，这是其中一次输出的截取：

23
23
23

23
23
23
23
23
23
23
23
23
28
23
21
23
23
23
23
25
28

可以看到有很多的重复数值，这是由于重排序导致事务结束后的值不同，但是你查看counter，确实是50:

@counter => 50

证明更新是没有问题的，问题出在commute的返回值上。

如果将next-counter修改为alter实现：

(defn next-counter [] (dosync (alter counter inc)))

此时再执行测试用例，可以发现打印结果完全正确了：

……
39
41
42
45
27
46
47
44
48
43
49
40
50

查看counter，也是正确更新到50了：

@counter => 50

最佳实践：通常情况下，你应该优先使用alter，除非在遇到明显的性能瓶颈并且对顺序不是那么关心的时候，可以考虑用commute替换。

6、validator：
类似数据库，你也可以为Ref添加“约束”，在数据更新的时候需要通过validator函数的验证，如果验证不通过，整个事务将回滚。添加validator是通过ref函数传入metadata的map实现的，例如我们要求歌曲集合添加的歌曲名称不能为空：

(def validate-song
(partial every? #(not (nil? %))))

(def song (ref #{} :validator validate-song))

validate-song是一个验证函数，partial返回某个函数的半函数（固定了部分参数，部分参数没固定），你可以将partial理解成currying，虽然还是不同的。validate-song调用every?来验证集合内的所有元素都不是nil，其中#(not (nil? %))是一个匿名函数，%指向匿名函数的第一个参数，也就是集合的每个元素。ref指定了validator为validate-song，那么在每次更新song集合的时候都会将新的状态传入validator函数里验证一下，如果返回false，整个事务将回滚：

(dosync (alter song conj nil))
java.lang.IllegalStateException: Invalid reference state (NO_SOURCE_FILE:0)

更新失败，非法的reference状态，查看song果然还是空的：

@song => #{}

更新正常的值就没有问题：

(dosync (alter song conj "dangerous")) => #{"dangerous"}

7、ensure:

ensure函数是为了保护Ref不会被其他事务所修改，它的主要目的是为了防止所谓的“写偏序”(write skew)问题。写偏序问题的产生跟STM的实现有关，clojure的STM实现是基于MVCC(Multiversion Concurrency Control)——多版本并发控制，对一个Ref保存多个版本的状态值，在更新的时候取得当前状态值的一个隔离的snapshot，更新是基于snapshot进行的。那么我们来看下写偏序是怎么产生，以一个比喻来描述：
想象有一个系统用于管理美国最神秘的军事禁区——51区的安全巡逻，你有3个营的士兵，每个营45个士兵，并且你需要保证总体巡逻的士兵人数不能少于100个人。假设有一天，有两个指挥官都登录了这个管理系统，他们都想从某个军营里抽走20个士兵，假设指挥官A想从1号军营抽走，指挥官B想要从2号军营抽走士兵，他们同时执行下列操作：

Admin 1: if ((G1 - 20) + G2 + G3) > 100 then dispatchPatrol

Admin 2: if (G1 + (G2 - 20) + G3) > 100 then dispatchPatrol

我们刚才提到，Clojure的更新是基于隔离的snapshot，一个事务的更改无法看到另一个事务更改了部分的结果，因此这两个操作都因为满足(45-20)+45+45=115的约束而得到执行，导致实际抽调走了40个士兵，只剩下95个士兵，低于设定的安全标准100人，这就是写偏序现象。
写偏序的解决就很简单，在执行抽调前加入ensure即可保护ref不被其他事务所修改。ensure比(ref-set ref @ref)允许的并发程度更高一些。

Ref和STM的介绍暂时到这里，原理和源码的解析要留待下一篇文章了。

dennis 2010-07-14 02:34 发表评论

Clojure的dosync是正则序？

dennis — Tue, 13 Jul 2010 04:02:00 GMT

解释器求值的顺序可以分为应用序和正则序，应用序是先求值参数，再执行表达式；正则序则是先将表达式按照实际参数展开，然后再执行。具体可以看看过去写的这篇文章。

Clojure的求值可以肯定是应用序的，如执行

(defn mytest [a b]
      (if (= a 0)
          a
          b))
(mytest 0 1/0)

尽管在(mytest 0 1/0)中a绑定为0，如果求值器是完全展开再求值，那应该正常执行并返回a，也就是1；但是因为clojure是应用序，因此参数b的1/0会先计算，这显然会报错。

clojure的dosync用于将一些表达式包装成事务，Ref的更新操作没有包装在事务里，会抛出异常

;;定义mutable的Ref
(def song (ref #{}))

;;添加一首歌
(alter song conj "dangerous")

alter用于向Ref查询并添加元素，用conj将"dangerous"这首歌加入集合，但是alter要求执行在一个事务里，因此上面的代码会报错

java.lang.IllegalStateException: No transaction running (NO_SOURCE_FILE:0)

如果你用dosync包装就没有问题

user=> (dosync (alter song conj "dangerous"))
#{"dangerous"}

返回更新后的结果集合。这个跟我们要谈的正则序和应用序有什么关系呢？可能你看出来了，如果说clojure是应用序，那么在表达式 (dosync (alter song conj "dangerous"))中，alter也应该先执行，应当照样报" No transaction running"的错误才对，为何却没有呢？难道dosync是按照正则序执行？

查看dosync的文档

user=> (doc dosync)
-------------------------
clojure.core/dosync
([& exprs])
Macro
  Runs the exprs (in an implicit do) in a transaction that encompasses
  exprs and any nested calls.  Starts a transaction if none is already
  running on this thread. Any uncaught exception will abort the
  transaction and flow out of dosync. The exprs may be run more than
  once, but any effects on Refs will be atomic.

这是一个宏，他的作用是将表达式包装在一个事务里，如果当前线程没有事务，那么就启动一个。
查看源码：

(defmacro dosync
  "Runs the exprs (in an implicit do) in a transaction that encompasses
  exprs and any nested calls.  Starts a transaction if none is already
  running on this thread. Any uncaught exception will abort the
  transaction and flow out of dosync. The exprs may be run more than
  once, but any effects on Refs will be atomic."
  [& exprs]
  `(sync nil ~@exprs))

本质上dosync是调用了sync这个宏，sync干了些什么？

(defmacro sync
  "transaction-flags => TBD, pass nil for now

  Runs the exprs (in an implicit do) in a transaction that encompasses
  exprs and any nested calls.  Starts a transaction if none is already
  running on this thread. Any uncaught exception will abort the
  transaction and flow out of sync. The exprs may be run more than
  once, but any effects on Refs will be atomic."
  [flags-ignored-for-now & body]
  `(. clojure.lang.LockingTransaction
      (runInTransaction (fn [] ~@body))))

找到了，原来是调用了clojure.lang.LockingTransaction.runInTransaction这个静态方法，并且将exps包装成一个匿名函数

fn [] ~@body

因此，dosync并非正则序,dosync是个宏，(dosync (alter song conj "dangerous"))展开之后，其实是

(sync nil (fun [] (alter song conj "dangerous")))

     这就解答了为什么(dosync (alter song conj "dangerous"))可以正常运行的疑问。宏的使用，首先是展开，然后才是按照应用序的顺序求值。

dennis 2010-07-13 12:02 发表评论

Clojure Hacking Guide

dennis — Sun, 11 Jul 2010 04:07:00 GMT

    这题目起的哗众取宠，其实只是想介绍下怎么查看Clojure动态生成的字节码，这对分析Clojure的内部实现很重要。

    第一步，下载最新的Clojure 1.1.0源码并解压，并导入到你喜欢的IDE。

    其次，下载asm 3.0的源码并解压。

    第三，删除Clojure 1.1.0源码中的clojure.asm包。clojure并不是引用asm的jar包，而是将asm的源码合并到clojure中，并且删除一些只会在调试阶段用到的package和class，保留使用asm的最小源码集合，这可能是处于防止asm不同版本的jar包冲突以及缩小clojure大小的考虑。

    第四，将asm 3.0源码拷入clojure的源码中，并将包org.objectweb.asm包括子包整体重名名为clojure.asm。

    第五步，修改Clojure源码，加入TraceClassVisitor的适配器，用于跟踪字节码生成，这需要修改clojure.lang.Compiler类中的两个compile方法，找到类似

ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS);
// ClassWriter cw = new ClassWriter(0);
ClassVisitor cv = cw;

这样的代码，将cv修改为TraceClassVisitor：

ClassVisitor cv = new TraceClassVisitor(new CheckClassAdapter(cw), new PrintWriter(System.out));

TraceClassVisitor的第二个参数指定将跟踪到的字节码输出到哪里，这里简单地输出到标准输出方便查看。

第六步，接下来可以尝试下我们修改过的clojure怎么动态生成字节码,启动REPL，

java clojure.main

启动阶段就会输出一些字节码信息，主要预先加载的一些标准库函数，如clojure.core中的函数等，REPL启动完毕，随便输入一个表达式都将看到生成的字节码

user=> (+ 1 2)

输出类似

compile 1
// class version 49.0 (49)
// access flags 33
public class user$eval__4346 extends clojure/lang/AFunction  {

  // compiled from: NO_SOURCE_FILE
  // debug info: SMAP
eval__4346.java
Clojure
*S Clojure
*F
+ 1 NO_SOURCE_FILE
NO_SOURCE_PATH
*L
0#1,1:0
*E

  // access flags 25
  public final static Lclojure/lang/Var; const__0

  // access flags 25
  public final static Ljava/lang/Object; const__1

  // access flags 25
  public final static Ljava/lang/Object; const__2

  // access flags 9
  public static <clinit>()V
   L0
    LINENUMBER 2 L0
    LDC "clojure.core"
    LDC "+"
    INVOKESTATIC clojure/lang/RT.var (Ljava/lang/String;Ljava/lang/String;)Lclojure/lang/Var;
    CHECKCAST clojure/lang/Var
    PUTSTATIC user$eval__4346.const__0 : Lclojure/lang/Var;
    ICONST_1
    INVOKESTATIC java/lang/Integer.valueOf (I)Ljava/lang/Integer;
    PUTSTATIC user$eval__4346.const__1 : Ljava/lang/Object;
    ICONST_2
    INVOKESTATIC java/lang/Integer.valueOf (I)Ljava/lang/Integer;
    PUTSTATIC user$eval__4346.const__2 : Ljava/lang/Object;
    RETURN
    MAXSTACK = 0
    MAXLOCALS = 0

  // access flags 1
  public <init>()V
   L0
    LINENUMBER 2 L0
   L1
    ALOAD 0
    INVOKESPECIAL clojure/lang/AFunction.<init> ()V
   L2
    RETURN
    MAXSTACK = 0
    MAXLOCALS = 0

  // access flags 1
  public invoke()Ljava/lang/Object; throws java/lang/Exception
   L0
    LINENUMBER 2 L0
   L1
    LINENUMBER 2 L1
    GETSTATIC user$eval__4346.const__1 : Ljava/lang/Object;
    GETSTATIC user$eval__4346.const__2 : Ljava/lang/Object;
    INVOKESTATIC clojure/lang/Numbers.add (Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Number;
   L2
    LOCALVARIABLE this Ljava/lang/Object; L0 L2 0
    ARETURN
    MAXSTACK = 0
    MAXLOCALS = 0
}
3

３就是表达式的结果。可以看到，一个表达式生成了一个class。其中是静态初始化块，主要是初始化表达式中的字面常量；不用说，默认的构造函数；invoke是核心方法，表达式生成的class，new一个实例后调用的就是invoke方法，执行实际的代码,高亮部分加载了两个常量，并执行Number.add方法。

最后，请Happy hacking!。

dennis 2010-07-11 12:07 发表评论

闭包使用的一个陷阱

dennis — Fri, 09 Jul 2010 15:52:00 GMT

来源：http://moonbase.rydia.net/mental/blog/programming/the-biggest-mistake-everyone-makes-with-closures.html

看下面的Ruby代码

k = []
for x in 1..3
k.push(lambda { x })
end

执行

k[0].call

你可能预期返回1，实际的结果却是3。这是为何？这是因为在迭代过程中共用了同一个context，导致k中的三个闭包都引用了同一个变量x。不仅仅Ruby有这个问题，python也一样

k = [lambda: x for x in xrange(1, 4)]
k[0]()

Javascript同样如此

var k = [];
for (var x = 1; x < 4; x++) {
k.push(function () { return x; });
}
alert(k[0]())

解决这个问题很简单，就是将闭包包装到一个函数里，建立新的context，那么迭代过程中生成的闭包所处的context不同：

def make_value_func(value)
lambda { value }
end
k = (1..3).map { |x| make_value_func(x) }

这个时候，k[0].call正确地返回1。

这个问题并非在所有支持闭包的语言里都存在，例如scheme中就没有问题

(define k '())
(do ((x 1 (+ x 1)))
((= x 4) '())
(set! k (cons (lambda () x) k)))
(set! k (reverse k))

((car k)) =>1

Erlang也没有问题

K=[ fun()->X end || X <- [1,2,3]].

lists:map(fun(F)-> F() end,K).

再试试Clojure:

(def k (for [i (range 1 4)] (fn [] i)))
(map #(%) k)

同样没有问题。这里Erlang和Clojure都采用列表推断。

dennis 2010-07-09 23:52 发表评论

Ruby Fiber指南（五）：实现Actor，兼谈Erlang的process调度

dennis — Tue, 13 Apr 2010 10:31:00 GMT

Ruby Fiber指南（一）基础
    Ruby Fiber指南（二）参数传递
    Ruby Fiber指南（三）过滤器
    Ruby Fiber指南（四）迭代器
    Ruby Actor指南（五）实现Actor

    写这个指南的时候，计划是第五章写一个Fiber的应用例子，但是一时没有想到比较好的例子，模仿《Programming in Lua》中的多任务下载的例子也不合适，因为Ruby中的异步HttpClient跟lua还是很不一样的，体现不了Fiber的优点。因此，这第五节一直拖着没写。
    恰巧最近在小组中做了一次Erlang的分享，有人问到Erlang调度器的实现问题，这块我没注意过，那时候就根据我对coroutine实现actor的想法做了下解释，后来思考了下那个解释是错误的，Erlang的调度器是抢占式的，而通过coroutine实现的actor调度却是非抢占的，两者还是截然不同的。我在《Actor、Coroutine和Continuation的概念澄清》中提到coroutine可以实现actor风格，actor跟coroutine并没有必然的联系，这篇文章的目的就在于证明这一点，使用Ruby Fiber实现一个简单的actor风格的库，整个代码不到100行。后面还会谈到这个实现的缺点，以及我对Erlang调度器实现的理解。

    首先是monkey patch，给Thread和Fiber类加上两个方法，分别用于获取当前线程的调度器和Fiber对应的actor:

class Thread
  #得到当前线程的调度器
  def __scheduler__
    @internal_scheduler||=FiberActor::Scheduler.new
  end
end

class Fiber
  #得到当前Fiber的actor
  def __actor__
    @internal_actor
  end
end

这里实现的actor仍然是Thread内的，一个Thread只跑一个调度器，每个actor关联一个Fiber。
让我们来想想调度器该怎么实现,调度器顾名思义就是协调actor的运行，每次挑选适当的actor并执行，可以想象调度器内部应该维护一个等待调度的actor队列，Scheduler每次从队列里取出一个actor并执行，执行完之后取下一个actor执行，不断循环持续这个过程；在没有actor可以调度的时候，调度器应该让出执行权。因此调度器本身也是一个Fiber，它内部有个queue，用于维护等待调度的actor：

module FiberActor
  class Scheduler
    def initialize
      @queue=[]
      @running=false
    end

    def run
      return if @running
      @running=true
      while true
        #取出队列中的actor并执行
        while actor=@queue.shift
          begin
            actor.fiber.resume
          rescue => ex
            puts "actor resume error,#{ex}"
          end
        end
        #没有任务，让出执行权
        Fiber.yield
      end
    end

    def reschedule
      if @running
        #已经启动，只是被挂起，那么再次执行
        @fiber.resume
      else
        #将当前actor加入队列
        self << Actor.current
      end
    end

    def running?
      @running
    end

    def <<(actor)
      #将actor加入等待队列
      @queue << actor unless @queue.last == actor
      #启动调度器
      unless @running
         @queue << Actor.current
         @fiber=Fiber.new { run }
         @fiber.resume
      end
    end
  end
end

run方法是核心的调度方法，注释说明了主要的工作流程。因为调度器可能让出执行权，因此提供了reschedule方法重新resume启动调度器。<<方法用于将等待被调度的actor加入等待队列，如果调度器没有启动，那么就启动调度Fiber。

有了调度器，Actor的实现也很简单，Actor跟Fiber是一对一的关系，Actor内部维护一个mailbox，用来存储接收到的消息。最重要的是receive原语的实现，我们这里很简单，不搞模式匹配，只是接收消息。receive的工作流程大概是这样，判断mailbox中有没有消息，有消息的话，取出消息并调用block处理，没有消息的话就yield让出执行权。

module FiberActor
  class Actor
    attr_accessor :fiber
    #定义类方法
    class << self
      def scheduler
        Thread.current.__scheduler__
      end

      def current
        Fiber.current.__actor__
      end

      #启动一个actor
      def spawn(*args,&block)
        fiber=Fiber.new do
           block.call(args)
        end
        actor=new(fiber)
        fiber.instance_variable_set :@internal_actor,actor
        scheduler << actor
        actor
      end

      def receive(&block)
        current.receive(&block)
      end
    end

    def initialize(fiber)
       @mailbox=[]
       @fiber=fiber
    end

    #给actor发送消息
    def << (msg)
      @mailbox << msg
      #加入调度队列
      Actor.scheduler << self
    end

    def receive(&block)
      #没有消息的时候，让出执行权
      Fiber.yield while @mailbox.empty?
      msg=@mailbox.shift
      block.call(msg)
    end

    def alive?
      @fiber.alive?
    end
  end

end

Actor.spawn用于启动一个actor，内部其实是创建了一个fiber并包装成actor给用户，每个actor一被创建就加入调度器的等待队列。<<方法用于向actor传递消息，传递消息后，该actor也将加入等待队列，等待被调度。

我们的简化版actor库已经写完了，可以尝试写几个例子，最简单的hello world:

include FiberActor

Actor.spawn { puts "hello world!"}

输出：

hello world!

没有问题，那么试试传递消息：

actor=Actor.spawn{
Actor.receive{ |msg| puts "receive #{msg}"}
}
actor << :test_message

输出：

receive test_message

也成了，那么试试两个actor互相传递消息，乒乓一下下：

pong=Actor.spawn do
      Actor.receive do |ping|
        #收到ping，返回pong
        ping << :pong
      end
    end
ping=Actor.spawn do
      #ping一下，将ping作为消息传递
      pong << Actor.current
      Actor.receive do |msg|
        #接收到pong
        puts "ping #{msg}"
      end
    end
#resume调度器
Actor.scheduler.reschedule

输出：

ping pong

     都没有问题，这个超级简单actor基本完成了。可以看到，利用coroutine来实现actor是完全可行的，事实上我这里描述的实现基本上是revactor这个库的实现原理。revactor是一个ruby的actor库，它的实现就是基于Fiber，并且支持消息的模式匹配和thread之间的actor调度，有兴趣地可以去玩下。更进一步，其实采用轻量级协程来模拟actor风格早就不是新鲜主意，比如在cn-erlounge的第四次会议上就有两个topic是关于这个，一个是51.com利用基于ucontext的实现的类erlang进程模型，一个是许世伟的CERL。可以想见，他们的基本原理跟本文所描述不会有太大差别，那么面对的问题也是一样。

   采用coroutine实现actor的主要缺点如下：
1、因为是非抢占式，这就要求actor不能有阻塞操作，任何阻塞操作都需要异步化。IO可以使用异步IO，没有os原生支持的就需要利用线程池，基本上是一个重复造轮子的过程。
2、异常的隔离，某个actor的异常不能影响到调度器的运转，简单的try...catch是不够的。
3、多核的利用，调度器只能跑在一个线程上，无法充分利用多核优势。
4、效率因素，在actor数量剧增的情况下，简单的FIFO的调度策略效率是个瓶颈，尽管coroutine的切换已经非常高效。

    当然，上面提到的这些问题并非无法解决，例如可以使用多线程多个调度器，类似erlang smp那样来解决单个调度器的问题。但是如调度效率这样的问题是很难解决的。相反，erlang的actor实现就不是通过coroutine，而是自己实现一套类似os的调度程序。
    首先明确一点，Erlang的process的调度是抢占式的，而非couroutine的协作式的。其次，Erlang早期版本是只有一个调度器，运行在一个线程上，随着erts的发展，现在erlang的调度器已经支持smp，每个cpu关联一个调度器，并且可以明确指定哪个调度器绑定到哪个cpu上。第三，Erlang的调度也是采用优先队列+时间片轮询的方式，每个调度器关联一个ErtsRunQueue，ErtsRunQueue内部又分为三个ErtsRunPrioQueue队列，分别对应high,max和normal,low的优先级，其中normal和low共用一个队列；在Erlang中时间片是以reduction为单位，你可以将reduction理解成一次函数调用，每个被调度的process能执行的reduction次数是有限的。调度器每次都是从max队列开始寻找等待调度的process并执行，当前调度的队列如果为空或者执行的reductions超过限制，那么就降低优先级，调度下一个队列。

   从上面的描述可以看出，Erlang优秀的地方不仅在于actor风格的轻量级process，另一个强悍的地方就是它的类os的调度器，再加上OTP库的完美支持，这不是一般方案能山寨的。

dennis 2010-04-13 18:31 发表评论

Actor、Coroutine和Continuation的概念澄清

dennis — Tue, 23 Mar 2010 03:49:00 GMT

Actor、Coroutine和Continuation这三个概念由于并发的受关注而被经常提到，这里主要想谈下这三者的区别和联系，以便更好的区分问题领域和讨论。首先，Actor和Coroutine在我看来是两种并发模型，仅针对于并发这个领域，而Continuation则是程序设计领域的一个概念，相比于Actor和Coroutine是一个更基础的概念。

那么，什么是Continuation？这个要从表达式的求值说起。一个表达式的求值可以分为两个阶段：“What to evaluate?”和“What to do with the value”，“What to do with the value”就是计算的Continuation。以下面这段代码为例：

if x<3 then
return x+1
else
return x
end

考察其中的表达式x<3，这个表达式就是“what to evaluate?”，代表你将计算的东西，然后根据x<3的结果决定是执行x+1还是直接返回x，这个根据x<3的值来决定下一步的过程就是这个表达式的Continuation，也就是"what to do with the value"。怎么得到某个表达式的Continuation呢？在支持Continuation的语言里提供了call-with-current-continuation的函数，通常简称为call/cc，使用这个函数你就可以在任何代码中得到Continuation。进一步，continuation有什么作用呢？它可以做的事情不少，如nonlocal exits、回溯、多任务的实现等等。例如在scheme中没有break语句，就可以用call/cc实现一些此类高级的控制结构：

(call/cc (lambda (break)
        (for-each (lambda (x) (if (< x 0) (break x)))
                '(99 88 -77 66 55))
        #t))

    上面这段代码查找列表(99 88 -77 66 55)中的负数，当查找到的时候马上从迭代中退出并返回该值，其中的break就是一个continuation。刚才还提到continuation可以实现回溯，那么就可以实现一个穷举的机器出来用来搜索解空间，也就是类似Prolog中的回溯机制，在SICP这本书里就介绍了如何用call/cc实现一个简单的逻辑语言系统。更著名的就是神奇的amb操作符，有兴趣可以看看这里。

     接下来我们来看看如何continuation实现多任务，在Continuation的维基百科里给了一段代码来展示如何用scheme来实现coroutine，我稍微修改了下并添加了注释:

;;continuation栈，保存了等待执行的continuation
(define call/cc call-with-current-continuation)
(define *queue* '())

(define (empty-queue?)
        (null? *queue*))

(define (enqueue x)
        (set! *queue* (append *queue* (list x))))

(define (dequeue)
        (let ((x (car *queue*)))
              (set! *queue* (cdr *queue*))
         x))
;;启动协程
(define (resume proc)
       (call/cc
         (lambda (k)
           ;;保存当前continuation，执行proc
           (enqueue k)
           (proc))))
;;让出执行权
(define (yield)
     (call/cc
      (lambda (k)
         ;;保存当前continuation，弹出上一次执行的cont并执行
        (enqueue k)
        ((dequeue)))))
;;停止当前协程或者当没有一个协程时停止整个程序,最简单的调度程序
(define (thread-exit)
     (if (empty-queue?)
         (exit)
         ((dequeue))))

（注：scheme以分号开头作为注释）

这其实就是一个coroutine的简单实现，context的保存、任务的调度、resume/yield原语……样样俱全。使用起来类似这样，下面这段程序轮流打印字符串：

(define (display-str str)
        (lambda()
         (let loop()
              (display str)
              (newline)
              (yield)
              (loop))))

;;;创建两个协程并启动调度器
(resume (display-str "This is AAA"))
(resume (display-str "Hello from BBB"))
(thread-exit)

任务非常简单，打印下传入的字符串并换行，然后让出执行权给另一个任务执行，因此输出：

This is AAA
Hello from BBB
This is AAA
Hello from BBB
This is AAA
Hello from BBB
This is AAA
Hello from BBB
……

    谈了这么多continuation的应用，事实上我想说明的是continuation可以用来实现协程，Ruby 1.9中call/cc和Fiber的实现（在cont.c)大体是一样的同样说明了这一点。

     接下来我们讨论下Actor和Coroutine的关系，上面提到Actor是一种并发模型，我更愿意称之为一种编程风格，Actor跟message passing、Duck Typing是一脉相承的。Actor风格是可以这么描述：将物理世界抽象成一个一个的Actor，Actor之间通过发送消息相互通信，Actor不关心消息是否能被接收或者能否投递到，它只是简单地投递消息给其他actor，然后等待应答。Actor相比于Coroutine是一种更高层次的抽象，它提供的receive和pattern match的原语更接近于现实世界，而使用coroutine编程你还需要手工介入任务调度，这在Actor中是由一个调度器负责的。

    同样，Actor可以用coroutine实现，例如Ruby有个revactor项目，就是利用1.9引入的Fiber实现actor风格的编程，它的实现非常简单，有兴趣地可以看看，其实跟continuation实现coroutine类似。但是Actor并不是一定要用coroutine才能实现，Actor是一种编程风格，你在Java、C#、C++中同样可以模拟这样的方式去做并发编程，.net社区的老赵实现过一个简单的Actor，Scala的Actor实现是基于外部库，利用scala强大的元编程能力使得库的使用像内置于语言。

    总结下我想表达的：Continuation是程序设计领域的基础概念，它可以用于实现coroutine式的多任务，Actor是一种比之coroutine更为抽象的编程风格，Actor可以基于Coroutine实现但并非必须，Actor和Coroutine都是现在比较受关注的并发模型。

dennis 2010-03-23 11:49 发表评论

Ruby Fiber指南（四）迭代器

dennis — Fri, 12 Mar 2010 04:48:00 GMT

Ruby Fiber指南（一）基础
    Ruby Fiber指南（二）参数传递
    Ruby Fiber指南（三）过滤器
    Ruby Fiber指南（四）迭代器
    Ruby Actor指南（五）实现Actor

     上一节介绍了利用Fiber实现类unix管道风格的过滤链，这一节将介绍利用Fiber来实现迭代器，我们可以将循环的迭代器看作生产者-消费者模式的特殊的例子。迭代函数产生值给循环体消费。所以可以使用Fiber来实现迭代器。协程的一个关键特征是它可以不断颠倒调用者与被调用者之间的关系，这样我们毫无顾虑的使用它实现一个迭代器，而不用保存迭代函数返回的状态，也就是说无需在迭代函数中保存状态，状态的保存和恢复交由Fiber自动管理。

     这一节的介绍以一个例子贯穿前后，我们将不断演化这个例子，直到得到一个比较优雅的可重用的代码，这个例子就是求数组的全排列。如数组[1,2,3]的全排列包括6种排列：

2 3 1
3 2 1
3 1 2
1 3 2
2 1 3
1 2 3

全排列的递归算法实现很简单，我们用Ruby实现如下：

#全排列的递归实现
def permgen (a, n)
    if n == 0 then
       printResult(a)
    else
        n.times do |i|
           a[n-1], a[i] = a[i], a[n-1]
           permgen(a, n - 1)
           a[n-1], a[i] = a[i], a[n-1]
       end
    end
end

def printResult (a)
    puts a.join(" ")
end

permgen([1,2,3,4],4)

算法的思路是这样：将数组中的每一个元素放到最后，依次递归生成所有剩余元素的排列，没完成一个排列就打印出来。很显然，这里有消费者和生产者的关系存在，生产者负责产生排列，消费者负责打印任务，整个程序由消费者驱动，因此用Fiber改写如下：

第一步，将打印任务修改为Fiber#yield，生产者产生一个排列后将结果传递给消费者并让出执行权：

def permgen (a, n)
    if n == 0 then
       Fiber.yield(a)
    ……
end

第二步，实现一个迭代器工厂，返回一个匿名的迭代函数，迭代函数请求Fiber产生一个新的排列：

def perm(a)
  f=Fiber.new do
        permgen(a,a.size)
    end
  return lambda{ f.resume if f.alive? }
end

这样一来我们就可以利用一个while循环来打印全排列：

it=perm([1,2,3,4])

while a=it.call
printResult(a)
end

注意到，在perm方法中有一个很常见的模式，就是将对Fiber的resume封装在一个匿名函数内，在lua为了支持这种模式还特意提供了一个coroutine.wrap方法来方便编程，在Ruby Fiber中却没有，不过我们可以自己实现下，利用open-class的特性实现起来非常简单：

#为Fiber添加wrap方法
class Fiber
  def self.wrap
    if block_given?
      f=Fiber.new do |*args|
         yield *args
      end
      return lambda{|*args| f.resume(*args) if f.alive? }
    end
  end
end

Fiber#wrap方法跟new方法一样，创建一个新的Fiber，但是返回的是一个匿名函数，这个匿名函数负责去调用fiber的resume，利用wrap改写perm方法变得更简洁：

def perm(a)
Fiber.wrap{ permgen(a,a.size) }
end

但是还不够，while循环的方式还是不够优雅，每次都需要明确地调用迭代器的call方法，这一点让人挺不舒坦，如果能像for...in那样的泛型循环就好了，我们知道Ruby中的for...in其实是一个语法糖衣，都是转变成调用集合的each方法并传入处理的block，因此，要想实现一个优雅的迭代器，我们做下封装就好了：

class FiberIterator
  def initialize
    @fiber_wrap=Fiber.wrap do
        yield
    end
  end
  def each
    while value=@fiber_wrap.call
      yield value
    end
  end
end

那么现在的perm方法变成了创建一个迭代器FiberIterator:

def perm(a)
FiberIterator.new{ permgen(a,a.size) }
end

这样一来我们就可以通过for...in来调用迭代器了

it=perm([1,2,3,4])
for a in it
printResult(a)
end

dennis 2010-03-12 12:48 发表评论

Ruby Fiber指南（三）过滤器

dennis — Thu, 11 Mar 2010 15:49:00 GMT

Ruby Fiber指南（一）基础
    Ruby Fiber指南（二）参数传递
    Ruby Fiber指南（三）过滤器
    Ruby Fiber指南（四）迭代器
    Ruby Actor指南（五）实现Actor

   在学习了Fiber的基础知识之后，可以尝试用Fiber去做一些比较有趣的事情。这一节将讲述如何使用Fiber来实现类似unix系统中的管道功能。在unix系统中，可以通过管道将多个命令组合起来做一些强大的功能，最常用的例如查找所有的java进程：

ps aux|grep java

通过组合ps和grep命令来实现，ps的输出作为grep的输入，如果有更多的命令就形成了一条过滤链。过滤器本质上还是生产者和消费者模型，前一个过滤器产生结果，后一个过滤器消费这个结果并产生新的结果给下一个过滤器消费。因此我们就从最简单的生产者消费者模型实现说起。
我们要展示的这个例子场景是这样：生产者从标准输入读入用户输入并发送给消费者，消费者打印这个输入，整个程序是由消费者驱动的，消费者唤醒生存者去读用户输入，生产者读到输入后让出执行权给消费者去打印，整个过程通过生产者和消费者的协作完成。
生产者发送是通过yield返回用户输入给消费者(还记的上一节吗？）：

def send(x)
Fiber.yield(x)
end

而消费者的接收则是通过唤醒生产者去生产：

def receive(prod)
prod.resume
end

生产者是一个Fiber，它的任务就是等待用户输入并发送结果给消费者：

def producer()
  Fiber.new do
    while true
      x=readline.chomp
      send(x)
    end
  end
end

消费者负责驱动生产者，并且在接收到结果的时候打印，消费者是root fiber:

def consumer(producer)
  while true
    x=receive(producer)
    break if x=='quit'
    puts x
  end
end

最终的调用如下：

consumer(producer())

完整的程序如下：

#生产者消费者
require 'fiber'

def send(x)
  Fiber.yield(x)
end

def receive(prod)
  prod.resume
end

def producer()
  Fiber.new do
    while true
      x=readline.chomp
      send(x)
    end
  end
end

def consumer(producer)
  while true
    x=receive(producer)
    break if x=='quit'
    puts x
  end
end
if $0==__FILE__
  consumer(producer())
end

读者可以尝试在ruby1.9下运行这个程序，每次程序都由消费者驱动生产者去等待用户输入，用户输入任何东西之后回车，生产者开始运行并将读到的结果发送给消费者并让出执行权（通过yield)，消费者在接收到yield返回的结果后打印这个结果，因此整个交互过程是一个echo的例子。

最终的调用consumer(producer())已经有过滤器的影子在了，如果我们希望在producer和consumer之间插入其他过程对用户的输入做处理，也就是安插过滤器，那么新的过滤器也将作为fiber存在，新的fiber消费producer的输出，并输出新的结果给消费者，例如我们希望将用户的输入结果加上行号再打印，那么就插入一个称为filter的fiber:

def filter(prod)
  return Fiber.new do
    line=1
    while true
      value=receive(prod)
      value=sprintf("%5d %s",line,value)
      send(value)
      line=line.succ
    end
  end
end

最终组合的调用如下：

consumer(filter(producer()))

类似unix系统那样，简单的加入新的fiber组合起来就可以为打印结果添加行号。

类似consumer(filter(producer()))的调用方式尽管已经很直观，但是我们还是希望能像unix系统那样调用，也就是通过竖线作为管道操作符：

producer | filter | consumer

这样的调用方式更将透明直观，清楚地表明整个过滤器链的运行过程。幸运的是在Ruby中支持对|方法符的重载，因此要实现这样的操作符并非难事,只要对Fiber做一层封装即可，下面给出的代码来自《Programming ruby》的作者Dave Thomas的blog：

class PipelineElement
   attr_accessor :source
   def initialize
      @fiber_delegate = Fiber.new do
         process
      end
   end

   def |(other)
      other.source = self
      other
   end

   def resume
      @fiber_delegate.resume
   end

   def process
      while value = input
         handle_value(value)
      end
   end

   def handle_value(value)
      output(value)
   end

   def input
      @source.resume
   end

   def output(value)
      Fiber.yield(value)
   end
end

这段代码非常巧妙，将Fiber和Ruby的功能展示的淋漓尽致。大致解说下，PipelineElement作为任何一个过滤器的父类，其中封装了一个fiber，这个fiber默认执行process，在process方法中可以看到上面生产者和消费者例子的影子，input类似receive方法调用前置过滤器(source)，output则将本过滤器处理的结果作为参数传递给yield并让出执行权，让这个过滤器的调用者（也就是后续过滤器）得到结果并继续处理。PipelineElement实现了“｜”方法，用于组合过滤器，将下一个过滤器的前置过滤器设置为本过滤器，并返回下一个过滤器。整个过滤链的驱动者是最后一个过滤器。

有了这个封装，那么上面生产者消费者的例子可以改写为：

class Producer < PipelineElement
   def process
     while true
       value=readline.chomp
       handle_value(value)
     end
   end
end

class Filter < PipelineElement
  def initialize
    @line=1
    super()
  end
  def handle_value(value)
    value=sprintf("%5d %s",@line,value)
    output(value)
    @line=@line.succ
  end
end

class Consumer < PipelineElement
  def handle_value(value)
    puts value
  end
end

现在的调用方式可以跟unix的管道很像了：

producer=Producer.new
filter=Filter.new
consumer=Consumer.new

pipeline = producer | filter | consumer
pipeline.resume

如果你打印pipeline对象，你将看到一条清晰的过滤链,

#, @source=#, @source=#>>>

dennis 2010-03-11 23:49 发表评论

Ruby Fiber指南（二）参数传递

dennis — Thu, 11 Mar 2010 10:41:00 GMT

Ruby Fiber指南（一）基础
    Ruby Fiber指南（二）参数传递
    Ruby Fiber指南（三）过滤器
    Ruby Fiber指南（四）迭代器
    Ruby Actor指南（五）实现Actor

    这一篇其实也算是Fiber编程的基础篇，只不过参数传递算是一个比较重要的主题，因此独立一节。参数传递发生在两个Fiber之间，作为Fiber之间通讯的一个主要手段。

    首先，我们可以通过resume调用给Fiber的block传递参数:

1 #resume传递参数给fiber
2 f=Fiber.new do |a,b,c|
3 p a,b,c
4 end
5
6 f.resume(1,2,3)
7

这个例子展示了怎么向fiber的block传递参数，f这个fiber简单地将传入的参数打印出来并终止。

其次，Fiber#yield也可以传递参数给调用resume作为返回结果，猜猜下面的代码打印什么？

1 #yield传递参数给resume
2 f=Fiber.new do |a,b|
3 Fiber.yield a+b,a-b
p a,b
4 end
5
6 p f.resume(10,10)
7 p f.resume(3,4)
8

正确的答案是：

[20, 0]
10
10
[10, 10]

让我们分析下代码的执行过程：
1、第6行第一次调用resume，传入10,10两个参数
2、f开始执行任务，它的任务是调用Fiber#yield，并将参数相加和相减的结果作为参数给yield，也就是执行Fiber.yield 20,10
3、f调用yield之后挂起，返回root fiber，yield的两个参数10、20作为返回结果打印。
4、第7行代码，root fiber再次调用resume并传入参数，f被切入并执行代码p a,b，打印a、b，a和b仍然是上次调用保存的10，而非resume传入的3和4。
5、f执行完毕，返回p a,b的结果作为resume结果，也就是[10,10]

刚才看到上面yield向resume传递参数的例子中第二次调用resume的参数3和4被忽略了，事实上如果还存在一次yield调用，那么3和4将被作为yield的返回结果使用，这就是我们接下来将看到的，通过resume调用传递参数作为fiber中yield的返回结果：

1 #resume传递参数给yield
2 f=Fiber.new do
3 1 + Fiber.yield
4 end
5
6 p f.resume(1)
7 p f.resume(2)
8

这次的打印结果将是：

nil
3

   第一次调用resume传入的1将被忽略，因为f的block不需要参数，然后f执行1 + Fiber.yield，在yield的挂起，加法运算没有继续，因为yield的调用没有参数，因此第一次resume返回nil；第二次resume调用传入2，这时候2将作为Fiber#yield的调用结果跟1相加,完成加法运算，得到的结果就是3，这个结果作为fiber的返回值返回给调用者。

    总结下上面我们谈到的四种传递参数的情形：通过resume向fiber的block传递参数、通过yield向调用者传递参数、通过resume向yield传递参数、fiber返回值传递给调用者。

dennis 2010-03-11 18:41 发表评论

Ruby Fiber指南（一）基础

dennis — Thu, 11 Mar 2010 04:53:00 GMT

Ruby Fiber指南（一）基础
    Ruby Fiber指南（二）参数传递
    Ruby Fiber指南（三）过滤器
    Ruby Fiber指南（四）迭代器
    Ruby Actor指南（五）实现Actor

    这是一个Ruby Fiber的教程，基本是按照《Programming in lua》中讲述协程章节的顺序来介绍Ruby Fiber的，初步分为5节：基础、参数传递、过滤器、迭代器、应用。这是第一节，介绍下Ruby Fiber的基础知识。

    Ruby 1.9引入了Fiber，通常称为纤程，事实上跟传统的coroutine——协程是一个概念，一种非抢占式的多线程模型。所谓非抢占式就是当一个协程运行的时候，你不能在外部终止它，而只能等待这个协程主动（一般是yield）让出执行权给其他协程,通过协作来达到多任务并发的目的。协程的优点在于由于全部都是用户空间内的操作，因此它是非常轻量级的，占用的资源很小，并且context的切换效率也非常高效（可以看看这个测试），在编程模型上能简化对阻塞操作或者异步调用的使用，使得涉及到此类操作的代码变的非常直观和优雅；缺点在于容错和健壮性上需要做更多工作，如果某个协程阻塞了，可能导致整个系统挂住，无法充分利用多核优势，有一定的学习使用曲线。
   上面都是场面话，先看看代码怎么写吧，比如我们写一个打印hello的协程：

1 require 'fiber'
2 f=Fiber.new do
3 p "hello"
4 end
5
6 p f.alive?
7 f.resume
8 p f.alive?
9
10 f.resume
11

附注：这里的代码都在ruby1.9.1-p378测试通过。

第一行先引入fiber库，事实上fiber库并不是必须的，这里是为了调用Fiber#alive?方法才引入。然后通过Fiber#new创建一个Fiber，Fiber#new接受一个block，block里就是这个Fiber将要执行的任务。Fiber#alive?用来判断Fiber是否存活，一个Fiber有三种状态：Created、Running、Terminated，分别表示创建完成、执行、终止，处于Created或者Running状态的时候Fiber#alive?都返回true。启动Fiber是通过Fiber#resume方法，这个Fiber将进入Running状态，打印"hello"并终止。当一个Fiber终止后，如果你再次调用resume将抛出异常，告诉你这个Fiber已经寿终正寝了。因此上面的程序输出是：

0
"hello"
false
fiber1.rb:10:in `resume': dead fiber called (FiberError)
from fiber1.rb:10:in `<main>'

眼尖的已经注意到了，这里alive?返回是0，而不是true，这是1.9.1这个版本的一个BUG，1.9.2返回的就是true。不过在Ruby里,除了nil和false，其他都是true。

刚才提到，我们为了调用Fiber#alive?而引入了fiber库，Fiber其实是内置于语言的，并不需要引入额外的库，fiber库对Fiber的功能做了增强，具体可以先看看它的文档，主要是引入了几个方法：Fiber#current返回当前协程，Fiber#alive?判断Fiber是否存活，最重要的是Fiber#transfer方法，这个方法使得Ruby的Fiber支持所谓全对称协程（symmetric coroutines），默认的resume/yield(yield后面会看到）是半对称的协程（asymmetric coroutines），这两种模型的区别在于“挂起一个正在执行的协同函数”与“使一个被挂起的协同再次执行的函数”是不是同一个。在这里就是Fiber#transfer一个方法做了resume/yield两个方法所做的事情。全对称协程就可以从一个协程切换到任意其他协程，而半对称则要通过调用者来中转。但是Ruby Fiber的调用不能跨线程（thread，注意跟fiber区分），只能在同一个thread内进行切换,看下面代码：

1 f = nil
2 Thread.new do
3 f = Fiber.new{}
4 end.join
5 f.resume

f在线程内创建，在线程外调用，这样的调用在Ruby 1.9里是不允许的，执行的结果将抛出异常

fiber_thread.rb:5:in `resume': fiber called across threads (FiberError)
from fiber_thread.rb:5:in `<main>'

刚才我们仅仅使用了resume，那么yield是干什么的呢？resume是使一个挂起的协程执行，那么yield就是让一个正在执行的Fiber挂起并将执行权交给它的调用者，yield只能在某个Fiber任务内调用，不能在root Fiber调用，程序的主进程就是一个root fiber,如果你在root fiber执行一个Fiber.yield，也将抛出异常：

Fiber.yield
FiberError: can't yield from root fiber

看一个resume结合yield的例子：

1 f=Fiber.new do
2   p 1
3   Fiber.yield
4   p 2
5   Fiber.yield
6   p 3
7 end
8
9 f.resume # =>打印1
10 f.resume # => 打印2
11 f.resume # =>打印3

f是一个Fiber，它的任务就是打印1,2,3，第一次调用resume时，f在打印1之后调用了Fiber.yield，f将让出执行权给它的调用者（这里就是root fiber)并挂起，然后root fiber再次调用f.resume，那么将从上次挂起的地方继续执行——打印2，又调用Fiber.yield再次挂起，最后一次f.resume执行后续的打印任务并终止f。

Fiber#yield跟语言中的yield关键字是不同的，block中的yield也有“让出”的意思，~~但是这是在同一个context里，而Fiber#yield让出就切换到另一个context去了，这是完全不同的。~~block的yield其实是匿名函数的语法糖衣，它是切换context的，跟Fiber不同的是，它不保留上一次调用的context，这个可以通过一个例子来区分：

1 def test
2    yield
3    yield
4    yield
5 end
6 test{x ||= 0; puts x+= 1}
7

这里的test方法接受一个block，三次调用yield让block执行，block里先是初始化x=0，然后每次调用加1，你期望打印什么？
答案是:

1
1
1

这个结果刚好证明了yield是不保留上一次调用的context，每次x都是重新初始化为0并加上1，因此打印的都是1。让我们使用Fiber写同一个例子：

1 fiber=Fiber.new do
2    x||=0
3    puts x+=1
4    Fiber.yield
5    puts x+=1
6    Fiber.yield
7    puts x+=1
8    Fiber.yield
9 end
10
11 fiber.resume
12 fiber.resume
13 fiber.resume
14

执行的结果是：

1
2
3

这次能符合预期地打印1，2，3，说明Fiber的每次挂起都将当前的context保存起来，留待下次resume的时候恢复执行。因此关键字yield是无法实现Fiber的，fiber其实跟continuation相关，在底层fiber跟callcc的实现是一致的（cont.c)。

Fiber#current返回当前执行的fiber，如果你在root fiber中调用Fiber.current返回的就是当前的root fiber，一个小例子：

1 require 'fiber'
2 f=Fiber.new do
3 p Fiber.current
4 end
5
6 p Fiber.current
7 f.resume

这是一次输出：

#
#

表明root fiber跟f是两个不同的Fiber。

基础的东西基本讲完了，最后看看Fiber#transfer的简单例子,两个协程协作来打印“hello world”：

1 require 'fiber'
2
3 f1=Fiber.new do |other|
4     print "hello"
5     other.transfer
6 end
7
8 f2=Fiber.new do
9     print " world\n"
10 end
11
12 f1.resume(f2)

通过这个例子还可以学到一点，resume可以传递参数，参数将作为Fiber的block的参数，参数传递将是下一节的主题。

dennis 2010-03-11 12:53 发表评论

Lua、LuaJIT Coroutine和Ruby Fiber的切换效率对比

dennis — Tue, 02 Mar 2010 03:50:00 GMT

最近重读了《Programming Lua》，对协程做了重点复习。众所周知，Ruby1.9引入了Fiber，同样是coroutine，不过Ruby Fiber支持全对称协程（通过fiber库)，而Lua只支持所谓半对称协程。

    这里将对Lua、LuaJIT和Ruby Fiber的切换效率做个对比测试，测试场景很简单：两个coroutine相互切换达到5000万次，统计每秒切换的次数,各测试多次取最佳。

    lua的程序如下：

c1=coroutine.create(function ()
                     while true do
                       coroutine.yield()
                     end
                    end)

c2=coroutine.create(function ()
                     while true do
                       coroutine.yield()
                     end
                    end)

local start=os.clock()
local count=50000000

for i=1,count do
coroutine.resume(c1)
coroutine.resume(c2)
end

print(4*count/(os.clock()-start))

考虑到在循环中事实上发生了四次切换：main->c1,c1->main,main->c2,c2->main，因此乘以4。

Ruby Fiber的测试分两种,采用transfer的例程如下：

require 'fiber'
require 'benchmark'

Benchmark.bm do |x|
  MAX_COUNT=50000000
  f1=Fiber.new do |other,count|
     while count<MAX_COUNT
      other,count=other.transfer(Fiber.current,count.succ)
     end
  end

  f2=Fiber.new do |other,count|
    while count<MAX_COUNT
      other,count=other.transfer(Fiber.current,count.succ)
    end
  end

  x.report{
    f1.resume(f2,0)
  }
end

Ruby Fiber采用resume/yield的例程如下：

require 'benchmark'
f1=Fiber.new do
  while true
    Fiber.yield
  end
end
f2=Fiber.new do
  while true
    Fiber.yield
  end
end

COUNT=50000000

Benchmark.bm do |x|
  x.report{
     COUNT.times do
         f1.resume
         f2.resume
     end
  }
end

     测试环境：
          CPU :    Intel(R) Core(TM)2 Duo CPU     P8600 @ 2.40GHz
          Memory: 3GB
          System : Linux dennis-laptop 2.6.31-14-generic #48-Ubuntu SMP
          Lua    : 5.1.4
          ruby : 1.9.1p378
          LuaJIT: 1.1.5和2.0.0-beta2

      测试结果如下：

	Lua	LuaJIT 1.1.5	LuaJIT 2.0.0-beta2	ruby-transfer	ruby-resume/yield
次数	6123698	9354536	24875620	825491	969649

      结论：
      1、lua的协程切换效率都是百万级别，luaJIT 2.0的性能更是牛叉，切换效率是原生lua的4倍，达到千万级别。
      2、相形之下,Ruby Fiber的效率比较差了，十万级别。
      3、Ruby使用transfer的效率比之resume/yield略差那么一点，排除一些测试误差，两者应该是差不多的，从ruby源码上看resume/yield和transfer的调用是一样的，resume还多了几条指令。
      4、额外信息，Ruby Fiber和lua coroutine都只能跑在一个cpu上，这个测试肯定能跑满一个cpu，内存占用上，lua也比ruby小很多。

dennis 2010-03-02 11:50 发表评论

Ruby Tip：定义索引操作符

dennis — Mon, 01 Feb 2010 08:29:00 GMT

怎么让你对象跟Array或者Hash一样，可以使用[ ]操作符来获取属性值或者赋值？问题其实就是如何定义index操作符，在Ruby中可以这样做：

class Message
   def initialize
    @props=Hash.new
   end
   def [](key)
      @props[key]
   end

   def []=(key,value)
      @props[key]=value
   end
end

m=Message.new

m[0]=1
p m[0]

m[:a]="hello"
p m[:a]

注意方法签名。

dennis 2010-02-01 16:29 发表评论

amb解决排列组合问题

dennis — Mon, 19 Oct 2009 03:37:00 GMT

看到这么一个题目：
{3,2,2,6,7,8}排序输出,7不在第二位,68不在一起。

这样的题目似乎避免不了遍历，关键还在于过滤条件的安排，怎么让过滤的范围尽量地小。通常的做法是循环遍历，对于类似Prolog这样的语言来说，由于内置了推理引擎，可以简单地描述问题，让引擎来帮你做递归遍历，解决这类问题是非常简单的。Prolog好久没写，以Ruby的amb操作符为例来解决这道题目：

#结果为hash，去重
$hash={}
amb=Amb.new
array=[3,2,2,6,7,8]
class << array
alias remove delete
def delete(*nums)
   result=dup
   nums.each do |n|
    result.delete_at(result.index(n)) if result.index(n)
   end
   result
end
end
#从集合选元素
one=amb.choose(*array)
two=amb.choose(*(array.delete(one)))
three=amb.choose(*(array.delete(one,two)))
four=amb.choose(*(array.delete(one,two,three)))
five=amb.choose(*(array.delete(one,two,three,four)))
six=amb.choose(*(array.delete(one,two,three,four,five)))

#条件1：第二个位置不能是7
amb.require(two!=7)
#条件2：6跟8不能一起出现
def six_eight_not_join(a,b)
   "#{a}#{b}"!="68"&&"#{a}#{b}"!="86"
end
amb.require(six_eight_not_join(one,two))
amb.require(six_eight_not_join(two,three))
amb.require(six_eight_not_join(three,four))
amb.require(six_eight_not_join(four,five))
amb.require(six_eight_not_join(five,six))

#条件3：不重复,利用全局hash判断
def distinct?(one,two,three,four,five,six)
  if $hash["#{one},#{two},#{three},#{four},#{five},#{six}"].nil?
     $hash["#{one},#{two},#{three},#{four},#{five},#{six}"]=1 #记录
     true
  else
     false
  end
end
amb.require(distinct?(one,two,three,four,five,six))
puts "#{one},#{two},#{three},#{four},#{five},#{six}"
amb.failure

三个条件的满足通过amb.require来设置，这里安排的只是一种顺序，可以根据实际测试结果来安排这些条件的顺序以最大程度地提高效率。代码注释很清楚了，我就不多嘴了。Ruby amb的实现可以看这里。什么是amb可以看这个。

dennis 2009-10-19 11:37 发表评论

Scheme的字符串操作

dennis — Mon, 12 Oct 2009 09:59:00 GMT

    字符串操作是任何一门编程语言中最常用的操作之一，scheme也提供了一系列procudure来操作字符串。

1、字符串的比较，有6个，分别是string=? string>? string=? string<=?

这与其他语言中对string的比较并无不同，比较字符和长度。

例子：
(string=? "mom" "mom") " /> #t
(string #t
(string>? "Dad" "Dad") " /> #f
(string=? "Mom and Dad" "mom and dad") " /> #f
(string #t

注意这些比较操作是大小写敏感。相应的，大小写不敏感的版本：

procedure: (string-ci=? string₁ string₂ string₃ ...)
procedure: (string-cistring₁ string₂ string₃ ...)
procedure: (string-ci>? string₁ string₂ string₃ ...)
procedure: (string-ci<=? string₁ string₂ string₃ ...)
procedure: (string-ci>=? string₁ string₂ string₃ ...)

2、从字符构造字符串，使用string过程
(string #\a) => "a"
(string #\a #\b #\c) => "abc"

注意，换行字符是#\newline,回车字符是#\return

3、重复N个字符构造字符串
(make-string) => ""
(make-string 4 #\a) =>"aaaa")

4、字符串长度 string-length
(string-length "") =>0
(string-length "dennis") => 6

5、取第N个字符，相当于java中的charAt：

(string-ref "hi there" 0) " /> #\h
(string-ref "hi there" 5) " /> #\e

6、修改字符串的第N个字符：
(string-set! "hello" 0 #\H) => "Hello"

7、拷贝字符串：
(let ((str "abc"))
(eq? str (string-copy str))) => #f
(let ((str "abc"))
(equal? str (string-copy str))) => #t

8、拼接字符串，string-append
(string-append) => ""
(string-append "abc" "defg") => "abcdefg"

9、截取子串
(substring "hi there" 0 1) " /> "h"
(substring "hi there" 3 6) " /> "the"
(substring "hi there" 5 5) " /> ""

10、填充字符串
(let ((str (string-copy "sleepy")))
  (string-fill! str #\Z)
  str) " /> "ZZZZZZ"

11、与list的相互转换

(string->list "") " /> ()
(string->list "abc") " /> (#\a #\b #\c)

(list->string '()) " /> ""
(list->string '(#\a #\b #\c)) " /> "abc"
(list->string
  (map char-upcase
       (string->list "abc"))) " /> "ABC"

dennis 2009-10-12 17:59 发表评论

Scala Ring Benchmark

dennis — Tue, 09 Jun 2009 05:42:00 GMT

Scala实现的ring benchmark：

import scala.actors.Actor
import scala.actors.Actor._
import java.util.concurrent.CountDownLatch
case class Message()
class Process(m:Int,p:Actor,latch:CountDownLatch) extends Actor{
  var next=p
  def act{
   loop{
     recvAndSend(m)
   }
  }
  def recvAndSend(count:Int){
     if(count==0){
        latch.countDown()
        exit
     }else{
       react{
         case Message()=>
           next! Message()
           recvAndSend(count-1)
         }
       }
     }
}
object RingBenchmark{
  def main(args:Array[String]){
    start(args(0).toInt,args(1).toInt)
  }
  def start(n:Int,m:Int){
     val latch=new CountDownLatch(n)
     val first=new Process(m,null,latch)
     val p=createProcess(first,n-1,m,latch)
     first.next=p
     val start:Long=System.currentTimeMillis
     first.start
     first!Message()
     latch.await()
     println(System.currentTimeMillis-start)
  }
  def createProcess(p:Actor,n:Int,m:Int,latch:CountDownLatch):Actor={
    if(n==0)
      p
    else{
     val next=new Process(m,p,latch)
     next.start
     createProcess(next,n-1,m,latch)
    }
  }
}

与Erlang版本的比较（单位毫秒),scala版本2.7.4-final，erlang是R13B, windows xp

N	M	Scala	Erlang
1000	100	297	62
1000	500	1328	343
1000	1000	2469	671
10000	100	2812	781
10000	1000	28796	7797

dennis 2009-06-09 13:42 发表评论

关于Object.object_id方法

dennis — Sun, 24 May 2009 04:46:00 GMT

Ruby中的Object.object_id是返回一个Fixnum类型的标识符来代表一个对象。没有两个active的对象的object_id是一样的，如：

a="1.8.6"
b="1.8.6"
a.object_id => 24393910
b.object_id => 24390830

尽管a==b，然而两者的object_id是不同。
但是这里有两种例外情况，对于常量，哪怕你将它赋给不同的变量，它们的object_id是一样的：

a=RUBY_VERSION
b=RUBY_VERSION
a.object_id => 21628310
b.object_id => 21628310

C="hello"
a=C
b=C
a.object_id => 24243480
b.object_id => 24243480

除此之外，对于symbol类型，返回的也将是同一个object_id：

a=:name
b=:name
a.object_id => 34258
b.object_id => 34258

为什么会出现这种情况？查看源码可知：

VALUE
rb_obj_id(VALUE obj)
{

   if (TYPE(obj) == T_SYMBOL) {
       return (SYM2ID(obj) * sizeof(RVALUE) + (4 << 2)) | FIXNUM_FLAG;
   }
   if (SPECIAL_CONST_P(obj)) {
       return LONG2NUM((long)obj);
   }
   return (VALUE)((long)obj|FIXNUM_FLAG);
}

Object.object_id方法对这两种情况做了特殊处理，常量和symbol都应当是唯一的。

dennis 2009-05-24 12:46 发表评论

scheme中文编程

dennis — Fri, 20 Mar 2009 15:27:00 GMT

摘要: 受javaeye上的《Ruby中文编程》启发，帖子中有人提到如果if这样的关键字都可以定义成中文，那就是真正的中文编程。那时我就想到，这个其实要在scheme中实现是多么简单，将sicp书中的解释器稍微修改下就可以了，只要修改解析的部分即可。解释器的完整代码放后面，我们先看看有趣的例子： Code highlighting produced by A... 阅读全文

dennis 2009-03-20 23:27 发表评论

安装配置Emacs-rails

dennis — Sat, 22 Nov 2008 18:22:00 GMT

首先你的机器上肯定要安装emacs啦，此步略过不表。
1、从 http://rubyforge.org/projects/emacs-rails 下载最新emacs-rails，解压文件到~/.emacs.d/rails 目录
2、根据README，你需要下载三个依赖库：

cd ~/.emacs.d/rails
wget http://www.kazmier.com/computer/snippet.el
wget http://www.webweavertech.com/ovidiu/emacs/find-recursive.txt
mv find-recursive.txt find-recursive.el

wget http://svn.ruby-lang.org/cgi-bin/viewvc.cgi/trunk/misc/inf-ruby.el?view=co
mv inf-ruby.el\?view=co inf-ruby.el

3、将ruby源代码目录下的/misc子目录中的emacs扩展文件拷贝到/usr/share/emacs/site-lisp/目录下：

sudo cp /home/dennis/backup/ruby-1.8.7-p72/misc/*.el /usr/share/emacs/site-lisp/

4、在~/.emacs添加两行代码，加载emacs-rails

(setq load-path (cons "~/.emacs.d/rails" load-path))
(require 'rails)

搞定，看起来挺强悍的，在菜单兰多了个ROR菜单，需要熟悉下快捷键。

dennis 2008-11-23 02:22 发表评论

ubuntu下解决Ruby安装后缺少openssl的问题

dennis — Sat, 22 Nov 2008 17:34:00 GMT

    一开始尝试使用
    sudo apt-get install libopenssl-ruby1.8
    安装是安装成功了，但是仍然提示找不到openssl。还是决定从源码安装，首先确保ubuntu安装了openssl：
    sudo apt-get install openssl
    sudo apt-get install libssl-dev
    sudo apt-get install libssl0.9.8

    然后进入ruby源码目录下的/ext/openssl
    cd RUBY_SOURCE/ext/openssl
    ruby extconf.rb
    make
    sudo make install

dennis 2008-11-23 01:34 发表评论

sicp 4.4.1小节习题

dennis — Sat, 22 Nov 2008 05:27:00 GMT

摘要: 本节开始进入第4章最后一部分——逻辑程序设计。scheme将实现一种查询语言，非常类似prolog。由于解释器的实现在后面，还未读到，前面的习题我都将用prolog做测试，当然也给出scheme版本的解答，待以后测试。首先给出依照书中所述写出的prolog事实库： Code highlighting prod... 阅读全文

dennis 2008-11-22 13:27 发表评论

使用Ruby amb解决说谎者谜题

dennis — Sat, 15 Nov 2008 10:50:00 GMT

    说谎者谜题是sicp4.3.2小节的一道题目，题目本身不难：
五个女生参加一个考试，她们的家长对考试结果过分关注。为此她们约定，在给家里写信谈到考试的时候，每个姑娘都要写一句真话和一句假话。下面是从她们的信里摘抄出来的句子：
Betty : kitty考第二，我只考了第三
Ethel : 你们应该很高兴听到我考了第一，joan第二
joan :   我考第三，可怜的Ethel垫底
kitty: 我第二，marry只考了第四
marry: 我是第四，Betty的成绩最高。
这五个姑娘的实际排名是什么？

    Ruby本来就有call/cc，因此也可以实现amb操作符，网上已经有一个实现了：

class Amb
  class ExhaustedError < RuntimeError; end
  def initialize
    @fail = proc { fail ExhaustedError, "amb tree exhausted" }
  end
  def choose(*choices)
    prev_fail = @fail
    callcc { |sk|
      choices.each { |choice|
        callcc { |fk|
          @fail = proc {
            @fail = prev_fail
            fk.call(:fail)
          }
          if choice.respond_to? :call
            sk.call(choice.call)
          else
            sk.call(choice)
          end
        }
      }
      @fail.call
    }
  end
  def failure
    choose
  end

  def assert(cond)
    failure unless cond
  end
  alias :require :assert
end

这一段代码与scheme宏实现amb是完全相同的：

(define amb-fail '*)

(define initialize-amb-fail
  (lambda ()
    (set! amb-fail
      (lambda ()
        (error "amb tree exhausted")))))

(initialize-amb-fail)
(define call/cc call-with-current-continuation)
(define-syntax amb
  (syntax-rules ()
    ((amb alt )
     (let ((prev-amb-fail amb-fail))
       (call/cc
        (lambda (sk)

          (call/cc
           (lambda (fk)
             (set! amb-fail
                   (lambda ()
                     (set! amb-fail prev-amb-fail)
                     (fk 'fail)))
             (sk alt)))

             (prev-amb-fail)))))))

回到谜题，从题意可知每个姑娘的两句话的异或结果为true，并且姑娘的排名肯定不会相同，因此定义两个辅助过程：

require 'amb'
def distinct?(items)
items.uniq==items
end
def xor(exp1,exp2)
(exp1 or exp2) and !(exp1 and exp2)
end

剩下的完全就是将题目翻译成代码即可了，没有多少可以解释的东西：

amb=Amb.new
betty=amb.choose(*[1,2,3,4,5])
ethel=amb.choose(*[1,2,3,4,5])
joan=amb.choose(*[1,2,3,4,5])
kitty=amb.choose(*[1,2,3,4,5])
marry=amb.choose(*[1,2,3,4,5])

amb.require(xor(kitty==2,betty==3))
amb.require(xor(ethel==1,joan==2))
amb.require(xor(joan==3,ethel==5))
amb.require(xor(kitty==2,marry==4))
amb.require(xor(marry==4,betty==1))
amb.require(distinct?([betty,ethel,joan,kitty,marry]))
puts "betty:#{betty} ethel:#{ethel} joan:#{joan} kitty:#{kitty} marry:#{marry}"

    答案就是：
    betty:3 ethel:5 joan:2 kitty:1 marry:4

    最后给出一个Prolog的解答：

notmember(A,[]).
notmember(A,[B|L]):-
  A\==B,
  notmember(A,L).
distinct([A,B,C,D,E]):-
   notmember(A,[B,C,D,E]),
   notmember(B,[A,C,D,E]),
   notmember(C,[A,B,D,E]),
   notmember(D,[A,B,C,E]),
   notmember(E,[A,B,C,D]).
xor(Exp1,Exp2):-
   (Exp1;Exp2),\+ (Exp1,Exp2).
solve(Betty,Ethel,Joan,Kitty,Marry):-
   X=[1,2,3,4,5],
   member(Betty,X),
   member(Ethel,X),
   member(Joan,X),
   member(Kitty,X),
   member(Marry,X),
   distinct([Betty,Ethel,Joan,Kitty,Marry]),
   xor(Kitty=:=2,Betty=:=3),
   xor(Ethel=:=1,Joan=:=2),
   xor(Joan=:=3,Ethel=:=5),
   xor(Kitty=:=2,Marry=:=4),
   xor(Marry=:=4,Betty=:=1).

dennis 2008-11-15 18:50 发表评论

降低JRuby的内存占用的可能方法

dennis — Fri, 14 Nov 2008 16:58:00 GMT

JRuby的内存占用是比较高的，毕竟需要启动一个JVM以及构建抽象语法树等，一般同一个脚本的内存占用都是CRuby的几十倍甚至上百倍。记的Infoq上有过一个新闻是说sun跟东京某大学合作研究Ruby和JRuby的MVM，可以在几个VM之间共享解释器，可以在启动多个VM的时候大大降低内存占用。不过这个项目暂时没有什么消息，要想在实际中应用更是没影的事情。有无其他解决办法？今天看到IBM Developer的一篇文章，原来IBM JRE for the Java platform SE 5早就引入了类共享的特性，也就是说允许通过缓存在 JVM 之间共享类来减少内存占用和重复加载类的开销。最新SR1 jvm更是引入了AOT编译的原生代码也可以放入共享缓存。那么，如果用ibm的支持类共享的VM来跑多个JRuby进程，会不会能大大减少整体的内存占用情况呢？可能出现的两个问题：
1、兼容性，IBM的jvm跑sun的JRuby，还是可能出现兼容性的问题。
2、JRuby的jar包中的类能否被共享？JRuby生成的语法树、Ruby运行时等能不能被共享？

有兴趣的童鞋可以测试一下，我的机器是AMD的，ibm jvm装不了，还是我下错了？

dennis 2008-11-15 00:58 发表评论

swfheader 0.10 Released（已更正下载地址）

dennis — Sat, 11 Oct 2008 15:38:00 GMT

update:俺确实够愚蠢了，竟然打包错了。半夜打包的，看来真有点头昏。非常抱歉，已经更正下载地址。

swfheader是一个处理swf文件的工具脚本，可用于读取swf文件头信息、压缩和解压缩swf文件。很早以前发布过一个0.01版。最近复审了代码，发现了一个愚蠢的读二进制文件错误导致没办法正确的解压或者压缩swf文件。今天更正了此bug，重构了部分代码并做了更多测试，已经可以正常使用。

项目地址:
http://code.google.com/p/swf-util/
项目描述：
一个轻量级的纯Ruby实现的swf文件处理脚本，可以读取swf文件头信息（大小、帧率、长宽、是否压缩、flash版本信息等）、压缩swf文件和解压缩swf文件。基于Apache License2协议发布。

示例
下载swfheader0.10.zip后，解压后有README文件和swfheader-0.10.gem，通过

gem install swfheader-0.10.gem

命令安装swfheader即可使用。

1、读文件头信息：

require 'swfheader'
header=SwfUtil::read_header("c:/test.swf"))
header.signature # 标志字符 CWS表示压缩的swf文件，FWS表示未压缩的
header.compression #compressed or uncompressed
header.size #文件大小
header.nbits #twips为单位的画面尺寸
header.xmax
header.ymax
header.width
header.height
header.version #flash版本
header.frame_date #帧率
header.frame_count #总帧数

header.inspect #信息描述字符串

header.inspect一个示例输出：

signature:   CWS
version:     8
compression: compressed
size:        5737111
nbits:       14
xmax:        7200
ymax:        5760
width:       360
height:      288
frameRate:   25
frameCount:  10409

2、解压缩swf文件，如果源文件本身没有被压缩那么将抛出异常：

require 'swfheader'
SwfUtil::decompress_swf("c:/test.swf","c:/test_decompressed.swf")

3、压缩swf文件,如果源文件已经被压缩将抛出异常：

require 'swfheader'
SwfUtil::compress_swf("c:/test.swf","c:/test_compressed.swf")

dennis 2008-10-11 23:38 发表评论

Ruby Tip——读文件

dennis — Tue, 07 Oct 2008 01:38:00 GMT

Ruby如何简洁地读整个文件，你可以这样做：

f=File.open("test.log","r")
result=''
f.each_line do |line|
result+=line
end
puts result

但是，更简洁的方法是：

File.open("test.log","r"){ |f| f.collect.join}

利用了文件打开的IO对象混入了Enumerable模块这一特点,通过map或者collect将所有文件行放入一个数组，再join即可。

更正，其实更简介的方法是：
IO.read("test.log")
仅限于读文本文件。

这个tip的由来是我在读二进制文件的时候发现IO.read出来的大小与实际结果不符合，然后去尝试上文提到的这个方法，其实仍然是错误的。读二进制文件需要指定mode为b：
File.open("test.swf","rb")

仅作更正。

dennis 2008-10-07 09:38 发表评论

Ruby 1.9概要（5）异常

dennis — Fri, 03 Oct 2008 05:26:00 GMT

1、异常的相等性，如果两个异常的class、message和backtrace一样，那么认为这两个异常是相等的，可以通过==判断。

def method
    raise 'foobar'
end

errors = []
2.times do
    Thread.new do
      begin
        method
      rescue => e
        errors << e
      end
    end.join
end
puts errors[-2] == errors[-1]    #=> true (1.9)   false(1.8)

2、SystemStackError现在继承Exception类，而非原来的StandardError:
1.8

SystemStackError < StandardError # => true

1.9

SystemStackError < StandardError # => nil
SystemStackError < Exception #=> true

3、移除了Exception#to_str方法：

begin
raise "foo"
rescue
$!.to_str
end

#=> undefind method "to_str" for #

dennis 2008-10-03 13:26 发表评论

Ruby 1.9概要（4） Block和Proc

dennis — Thu, 02 Oct 2008 05:54:00 GMT

1、Proc加了新方法Proc#yield,这只是Proc#call的别名方法，是为了能让Proc也可以像block那样传入方法并且调用yield。

a_proc = Proc.new {|a,b| a+b}
a_proc.yield(1,2) # => 3

def test(&block)
block.yield(1,2,3)
end
test do |a,b|
a+b # => 3
end
test &a_proc # =>3

2、没有参数的block的基数（参数个数,arity）：
1.8

lambda{}.arity #=> -1

1.9

lambda{}.arity #=> 0

所谓arity就是方法调用无法忽略的参数个数。这跟Erlang,Prolog中的arity的概念并无二致。

3、proc关键字现在是Proc.new的同义词，proc在1.8的时候跟lambda关键字是同义词，也就是proc定义的是一个lambda而非字面

意义上的Proc，1.9改过来了。
1.9:

proc{|a,b|}.arity        # => 2
proc{|a,b|}.call(1)        # => nil
Proc.new{|a,b|}.arity        # => 2
Proc.new{|a,b|}.call(1)        # = nil

1.8:

proc{|a,b|}.arity        # => 2
proc{|a,b|}.call(1)        # => ERROR: (eval):1: wrong number of arguments (1 for 2)
Proc.new{|a,b|}.arity        # => 2
Proc.new{|a,b|}.call(1)        # => nil

1.8时候第二个调用出错的原因在于lambda在调用参数过多过少的时候都将报error，这是lambda跟Proc的一个区别之一。

4、Proc#lambda? 用来判断某个Proc是否具有lambda语义或者block语义：

lambda{}.lambda? #=>true
proc{}.lambda? # =>false
Proc.new{}.lambda? # =>false

dennis 2008-10-02 13:54 发表评论

Ruby 1.9概要（3）类和模块

dennis — Wed, 01 Oct 2008 05:52:00 GMT

三、类和模块
1、Module#instance_methods, #private_instance_methods, #public_instance_methods Module这三个方法都将返回方法名

的symbol组成的数组，而非过去的字符串数组。

2、Module#const_defined?, #const_get 这两个方法都添加一个参数flag，用来决定是否将它的ancestor中的const包括在查
找链中，例如：

module A; X = 1; def foo; end end
module B
  include A
  const_defined? "X"                              # => true
  const_defined? "X",false                        #uninitialized constant
  const_get "X"                                   # => 1
  const_get "X",false                             #uninitialized constant
end

3、Module#class_variable_defined?方法：

class X; end
X.class_variable_defined? :@@a # => false
class X; @@a = 1 end
X.class_variable_defined? :@@a # => true

class_variable_{get,set}方法：

class B; self end.class_variable_set(:@@a, "foo") # => "foo"

4、Module#attr等价于Module#attr_reader:

class Test
  attr:foo
  def initialize
    @foo=3
  end
end
t=Test.new
puts t.foo   #=>3
t.foo=4     #undefined method "foo="

5、接下来是一个bug fix的问题。下面这段代码是为了证明对象的singleton类继承自对象的类：

class X;end; x=X.new; class << x;p self < X; end

在1.8上，这段代码打印nil，这是不符合Ruby的对象模型的，因此在1.9运行已经可以打印正确结果true了。
如果不理解这点，参照俺过去写的《Ruby对象模型》

6、新增Module#module_exec方法，与Object#instance_exec类似

7、绑定未绑定的方法时进行额外的子类型检查,例如下面的代码：

class Foo; def foo; end end
module Bar
define_method(:foo, Foo.instance_method(:foo))
end
a=""
a.extend Bar
a.foo

在1.8上，这段代码只有当执行到a.foo的时候才报错："foo":bind arguments must be an instance of Foo(TypeError)
因为foo是Foo的instance method，因此调用者必须是Foo或者其子类的instance。而在1.9中，在绑定还没有绑定的方法的时候引入了额
外的检查，因此上面这段代码不必等到a.foo调用就将报错：

class Foo; def foo; end end
module Bar
define_method(:foo, Foo.instance_method(:foo)) #=》 in "defined_method":bind arguments must be a subclass

of Foo<TypeError>
end

8、binding#eval方法，新增加的：

a=1
binding.eval("p a") => 1

这个貌似与1.8中的：

a=1
eval("a",binding)

没有什么不同。

dennis 2008-10-01 13:52 发表评论

Ruby 1.9概要（2）Kernel和Object

dennis — Wed, 01 Oct 2008 05:48:00 GMT

二、Kernel 和 Object
1、引入了BasicObject对象，作为一个顶级的空白状态对象：

BasicObject.instance_methods # => [：==，：equal?,:"!",:"!=",:__send__]
Object.ancestors # => [Object, Kernel, BasicObject]

引入这个对象对于Ruby对象体系带来的影响我还不清楚。
2、instance_exec方法，允许传递参数、self到一个block并执行之,也就是说为特定的instance执行block。

def magic(obj)
   def obj.foo(&block)
     instance_exec(self, a, b, &block)
   end
end
o = Struct.new(:a,:b).new(1,2)
magic(o)
puts o.foo{|myself,x,y| puts myself.inspect;x + y }

更多例子：

o = Struct.new(:val).new(1)
o.instance_exec(1){|arg| val + arg } =>2

在Ruby 1.8中实现这个方法：

class Object
  module InstanceExecHelper; end
  include InstanceExecHelper
  def instance_exec(*args, &block) # !> method redefined; discarding old instance_exec
    mname = "__instance_exec_#{Thread.current.object_id.abs}_#{object_id.abs}"
    InstanceExecHelper.module_eval{ define_method(mname, &block) }
    begin
      ret = send(mname, *args)
    ensure
      InstanceExecHelper.module_eval{ undef_method(mname) } rescue nil
    end
    ret
  end
end

3、Kernel的require方法载入的文件将以完整路径存储在变量$"中，等价于：

$" << File.expand_path(loaded_file)

通过在irb中观察$"变量即可看出差别。

4、Object#tap方法，将对象传入block并返回自身，用于链式调用：

"hello".tap{|a| a.reverse!}[0] #=> "o"
"F".tap{|x| x.upcase!}[0] #=> "F" （注意到"F".upcase!返回的是nil)

5、Kernel#instance_variable_defined?方法：

a = "foo"
a.instance_variable_defined? :@a # => false
a.instance_variable_set(:@a, 1)
a.instance_variable_defined? :@a # => true

6、Object#=~

匹配失败的时候返回nil而不是false

1 =~ 1 # => nil

7、Kernel#define_singleton_method 方法，

a = ""
a.define_singleton_method(:foo){|x| x + 1}
a.send(:foo,2) =>3
a.foo(2) => 3

8、Kernel#singleton_methods, Kernel#methods,返回的是将是方法名symbol组成的数组，过去是方法名的字符串数组。

dennis 2008-10-01 13:48 发表评论

Ruby 1.9概要（1）新的语法和语义

dennis — Wed, 01 Oct 2008 05:37:00 GMT

一、新的语法和语义
1、新的Hash定义语法：
例如{a:2} 等价于 {:a=>2}
但是 {"a":2} 出错，并不等价于 {:"a"=>2}

2、试验性质的block内的局部变量
在1.8，block的与外部同名的变量是同一个变量，也就是说block内的变量也可以修改外部的同名变量，这很容易形成难以查找的bug。
例子：

# {常规参数;局部变量}
d = 2
a = lambda{|;d| d = 1}
a.call()
d # => 2

注意到，分号后的d是block局部变量。

3、block的参数现在都是局部变量

4、新lambda语法，试验性质：

->a,b {a+b}.call(1,2) => 3

一些比较诡异的写法：

-> { }.call # => nil
-> a, b { a + b }.call(1,2) # => 3
c = 1; -> a, b; c { c = a + b }.call(1,2); c # => 1（注意这里，;号的c是block的局部变量，因此c=1在lambda调用前后没有改变。）

5、 .()的调用方式
过去

lambda{|*d| d}.call(1,2,3)

现在可以简化为

lambda{|*d| d}.(1,2,3)

.()这样的方式都将调用接受者的call方法，无论接收者是什么，例如：

"foo".(1,2) # ~> undefined method `call' for "foo":String (NoMethodError)

显然，这个方式另一种形式上的method_missing，比如在类中应用：

class Test
  def self.call(*d)
     d
   end
end
Test.(1,2,3)  => [1,2,3]

这个特性也是试验性质

6、block可以使用&block做参数咯。
例子：

class Test
define_method :foo lambda{|&b| b.call("hello")}
end
t=Test.new
t.foo do |b|
puts b => hello
end

7、新的block参数语义，|v| 现在等价于 |v,|
还是通过例子吧：
1.8：

def m; yield 1, 2; end
m{|v| v} # => [1, 2]
# !> multiple values for a block parameter (2 for 1)

1.9：

def m; yield 1, 2; end
m{|v| v} # => 1

8、允许数组多重展开

def foo(*a)
     a
end
foo(1, *[2,3], 4, *[5,6])                        # => [1, 2, 3, 4, 5, 6]

a = [1,2,3]
b = [4,5,6]
[*a, *b]                                         # => [1, 2, 3, 4, 5, 6]

9、可选参数后允许再有强制参数的存在，这在过去是不允许的。例如下面的代码在1.8是错误的，而1.9却可以正常运行：

def foo(a,b="test",c)
  puts c
end
foo(1)   => wrong number of arguments(1 for 2)
foo(1,2) => 2
foo(1,3) => 3
foo(1,2,3)  =>3

更复杂的：

def m(a, b=nil, *c, d)
     [a,b,c,d]
end
m(1)  =>error
m(1,2)  => [1,nil,[],2]
m(1,2,3) =>[1,2,[],3]
m(1,2,3,4)  =>[1,2,[3],4]
m(1,2,3,4,5)   => [1,2,[3,4],5]
m(1,2,3,4,5,6]  =>[1,2,[3,4,5],6]

10、?c的语义，过去?+字符返回字符的ascii码整数，现在返回字符"c"
例如：

?a => 97 (1.8)
?a => "a" (1.9)

11、[]方法的参数现在可以将数组和hash联合使用，例如下面的例子：

class Test
   def [](*a)
     puts a.inspect
   end
end
a=[1,2,3]
Test.new[*a,:a=>2]   =>  SyntaxERROR:compire error (1.8)
Test.new[*a,:a=>2] =>  [1,2,3,{:a=>2}] (1.9)

12、打印字符，打印字符和负数，

1.8：
  printf "%c","a"  => can't convert String into Integer
  printf "%u",-1   => ..4294967295

1.9:
  printf "%c","a"  => a
  printf "%u",-1   => -1

13、defined?方法和local variable:

RUBY_VERSION                                      # => "1.8.5"
RUBY_RELEASE_DATE                                 # => "2006-08-25"
a = 0
defined? a                                        # => "local-variable"
1.times do |i|
  defined? i                                      # => "local-variable(in-block)"
end

VS.

RUBY_VERSION                                      # => "1.9.0"
RUBY_RELEASE_DATE                                 # => "2007-08-03"
a = 0
defined? a                                        # => "local-variable"
1.times do |i|
  defined? i                                      # => "local-variable"
end

dennis 2008-10-01 13:37 发表评论