[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8},"actionData","errors","root",{"_11":-5},"routes/user.$name.topics",{"_9":10,"_11":12,"_13":14,"_15":16,"_17":18,"_19":20},"topics",[35,36],"user",{"_21":22,"_13":14,"_23":24,"_25":26,"_27":28,"_29":30,"_31":16,"_32":16,"_33":34},"loginname","zealot","page",1,"limit",20,"total",2,"id","1105","avatar_url","http://www.gravatar.com/avatar/1093fec993109b46d2f20963e52718bc?s=48","githubUsername","","create_at","2011-10-31 18:54:10","score",10,"topic_count","reply_count","is_star",false,{"_21":54,"_38":22,"_39":-5,"_40":55,"_42":56,"_44":57,"_46":34,"_47":34,"_32":48,"_49":58,"_27":59,"_52":60},{"_21":37,"_38":22,"_39":-5,"_40":41,"_42":43,"_44":45,"_46":34,"_47":34,"_32":48,"_49":50,"_27":51,"_52":53},"51","author_id","tab","content","本文介绍一个使用大概10行代码, 实现一个类似老赵JSCEX的工具
\r\n

\r\n
首先来看一下下面这段Node.js代码:
\r\n

\r\n

\r\n
var copy = function(src, dst) {\r\n
\tvar fd_src = fs.open(src, \"r\");\r\n
\tvar fd_dst = fs.open(dst, \"w\");\r\n
\twhile (true) {\r\n
\t\tvar buffer_size = 4096;\r\n
\t\tvar buffer = new Buffer(buffer_size);\r\n
\t\tvar bytes_read = fs.read(fd_src, buffer, 0, buffer_size);\r\n
\t\tif (bytes_read > 0) {\r\n
\t\t\tvar write_at = 0;\r\n
\t\t\twhile (write_at < bytes_read) {\r\n
\t\t\t\twrite_at += fs.write(fd_dst, buffer, write_at, bytes_read - write_at);\r\n
\t\t\t}\r\n
\t\t} else {\r\n
\t\t\tbreak;\r\n
\t\t}\r\n
\t}\r\n
};\r\n

\r\n

\r\n
这段看起来像是一个文件拷贝的函数, 但是这个函数在Node里面是无法运行的, 因为Node的所有函数调用都必须是异步的, 这里用到的fs.open, fs.read, fs.write都必须修改为异步调用, 修改后可运行的代码如下:
\r\n

\r\n

\r\n
var copy = function(src, dst) {\r\n
\tfs.open(src, \"r\", undefined, function(err, fd_src) {\r\n
\t\tfs.open(dst, \"w\", undefined, function(err, fd_dst) {\r\n
\t\t\tvar copy_rec = function(position) {\r\n
\t\t\t\tvar buffer_size = 4096;\r\n
\t\t\t\tvar buffer = new Buffer(4096);\r\n
\t\t\t\tfs.read(fd_src, buffer, 0, buffer_size, position, function(err, bytes_read) {\r\n
\t\t\t\t\tif (bytes_read > 0) {\r\n
\t\t\t\t\t\tvar write_rec = function(write_at) {\r\n
\t\t\t\t\t\t\tif (write_at  0) {\r\n
\t\t\t\t\t\t\t\t\t\twrite_rec(write_at + written);\r\n
\t\t\t\t\t\t\t\t\t}\r\n
\t\t\t\t\t\t\t\t});\r\n
\t\t\t\t\t\t\t} else {\r\n
\t\t\t\t\t\t\t\tcopy_rec(position + bytes_read);\r\n
\t\t\t\t\t\t\t}\r\n
\t\t\t\t\t\t};\r\n
\t\t\t\t\t\twrite_rec(0);\r\n
\t\t\t\t\t}\r\n
\t\t\t\t});\r\n
\t\t\t};\r\n
\t\t\tcopy_rec(0);\r\n
\t\t});\r\n
\t});\r\n
};\r\n

\r\n

\r\n
看到这里, 我想第一次接触Node的同学就已经要崩溃了, 一个简单的文件拷贝函数竟然需要嵌套4~5层函数回调, 那么更复杂的比如web servlet岂不是要嵌套10多层函数回调了?
\r\n

\r\n
难道没有方法让最上面的简洁明了的代码运行起来么? 下面就介绍一种方法, 不修改最开始那个简洁明了的拷贝函数, 让它直接跑起来, 并且不会阻塞整个JS引擎
\r\n

\r\n
首先分析一下同步调用与异步调用的区别
\r\n

\r\n
// sync\r\n
var fd = fs.read (name, mode);\r\n
// use fd\r\n
\r\n
\r\n
// async\r\n
fs.read (name, mode, function (fd) {\r\n
\t// use fd\r\n
});\r\n

\r\n

\r\n
仔细观察这两个调用, 会发现其实这就是一个CPS变换, 所以, 我们只需要做一个CPS变换的包装就可以实现同步的文件操作, 具体实现如下:
\r\n

\r\n

\r\n
var efs = {\r\n
\topen: function (name, mode) {\r\n
\t\treturn call_cc(function (continuation) {\r\n
\t\t\tfs.open(name, mode, undefined, function(err, fd_src) {\r\n
\t\t\t\tcontinuation(fd_src);\r\n
\t\t\t});\r\n
\t\t});\r\n
\t},\r\n
\tread: function (fd, buffer, offset, length) {\r\n
\t\treturn call_cc(function (continuation) {\r\n
\t\t\tfs.read(fd, buffer, offset, length, null, function(err, bytes_read) {\r\n
\t\t\t\tcontinuation(bytes_read);\r\n
\t\t\t});\r\n
\t\t});\r\n
\t},\r\n
\twrite: function (fd, buffer, offset, length) {\r\n
\t\treturn call_cc(function (continuation) {\r\n
\t\t\tfs.write(fd, buffer, offset, length, null, function(err, written) {\r\n
\t\t\t\tcontinuation(written);\r\n
\t\t\t});\r\n
\t\t});\r\n
\t}\r\n
};\r\n

\r\n

\r\n
这个实现的核心就是call/cc函数, 如果了解lisp或者scheme的同学可能会非常熟悉这个函数, 这个函数作用是把当前正在运行的线程挂起, 然后执行call/cc本体, call/cc函数不会返回, 直到主动调用参数传进来的那个回调函数(本例中continuation变量绑定的函数), call/cc函数的返回值就是传给回调函数的参数. call/cc函数确实很难理解, 下面举例说明一下:
\r\n

\r\n

\r\n
util.log(\"before call/cc\");\r\n
var result = call_cc(function (continuation) {\r\n
\tutil.log(\"in call/cc before set timer\");\r\n
\tsetTimeout(function () {\r\n
\t\tutil.log(\"before callback\");\r\n
\t\tcontinuation(\"hello world!\");\r\n
\t\tutil.log(\"after callback\");\r\n
\t}, 1000);\r\n
\tutil.log(\"in call/cc after set timer\");\r\n
});\r\n
util.log(\"after call/cc \" + result);\r\n

\r\n

\r\n
这段代码的输出为:
\r\n

\r\n

\r\n
31 Oct 13:01:33 - before call/cc\r\n
// 运行call/cc函数主体\r\n
31 Oct 13:01:33 - in call/cc before set timer\r\n
31 Oct 13:01:33 - in call/cc after set timer\r\n
// 休息1秒, 进入setTimeout的回调\r\n
31 Oct 13:01:34 - before callback\r\n
// 进入continuation函数, 调用continuation函数就相当于call/cc函数返回了\"hello world!\", 从call/cc返回开始继续执行\r\n
31 Oct 13:01:34 - after call/cc hello world!\r\n
// 执行setTimeout回调剩下部分\r\n
31 Oct 13:01:34 - after callback\r\n

\r\n

\r\n
现在我们已经使用CPS转换得到了\"同步\"的文件处理函数, 虽然说看起来是同步的, 但是内部使用的是call/cc实现, 实际上是不会阻塞JS引擎的, 其他回调仍然能正常执行. 有了这些函数的支持, 本文开头给出的那个文件拷贝函数就能够不作任何修改正常执行, 现在一切问题都已经解决了, 唯一剩下的问题就是call/cc函数的实现, 标准的node.js引擎是没有call/cc函数的, 这里我们使用node-fibers实现call/cc函数.
\r\n

\r\n

\r\n
var call_cc = function(cont) {\r\n
\tvar fiber = Fiber.current;\r\n
\tcont(function (a) {\r\n
\t\tfiber.run(a);\r\n
\t});\r\n
\treturn Fiber[\"yield\"]();\r\n
};\r\n

\r\n

\r\n
由于node-fiber的限制, 这个copy函数必须运行在fiber环境中, 完整代码如下:
\r\n

\r\n

\r\n
var fs = require(\"fs\");\r\n
require(\"fibers\");\r\n
\r\n
var call_cc = function(cont) {\r\n
\tvar fiber = Fiber.current;\r\n
\tcont(function (a) {\r\n
\t\tfiber.run(a);\r\n
\t});\r\n
\treturn Fiber[\"yield\"]();\r\n
};\r\n
\r\n
var efs = {\r\n
\topen: function (name, mode) {\r\n
\t\treturn call_cc(function (continuation) {\r\n
\t\t\tfs.open(name, mode, undefined, function(err, fd_src) {\r\n
\t\t\t\tcontinuation(fd_src);\r\n
\t\t\t});\r\n
\t\t});\r\n
\t},\r\n
\tread: function (fd, buffer, offset, length) {\r\n
\t\treturn call_cc(function (continuation) {\r\n
\t\t\tfs.read(fd, buffer, offset, length, null, function(err, bytes_read) {\r\n
\t\t\t\tcontinuation(bytes_read);\r\n
\t\t\t});\r\n
\t\t});\r\n
\t},\r\n
\twrite: function (fd, buffer, offset, length) {\r\n
\t\treturn call_cc(function (continuation) {\r\n
\t\t\tfs.write(fd, buffer, offset, length, null, function(err, written) {\r\n
\t\t\t\tcontinuation(written);\r\n
\t\t\t});\r\n
\t\t});\r\n
\t}\r\n
};\r\n
\r\n
var copy = function(src, dst) {\r\n
\tvar fd_src = efs.open(src, \"r\");\r\n
\tvar fd_dst = efs.open(dst, \"w\");\r\n
\twhile (true) {\r\n
\t\tvar buffer_size = 4096;\r\n
\t\tvar buffer = new Buffer(buffer_size);\r\n
\t\tvar bytes_read = efs.read(fd_src, buffer, 0, buffer_size);\r\n
\t\tif (bytes_read > 0) {\r\n
\t\t\tvar write_at = 0;\r\n
\t\t\twhile (write_at < bytes_read) {\r\n
\t\t\t\twrite_at += efs.write(fd_dst, buffer, write_at, bytes_read - write_at);\r\n
\t\t\t}\r\n
\t\t} else {\r\n
\t\t\tbreak;\r\n
\t\t}\r\n
\t}\r\n
};\r\n
\r\n
Fiber(function () {\r\n
\tcopy(\"src\", \"dst\");\r\n
}).run();\r\n

\r\n

\r\n

\r\n
最后一点空间, 我想简单评论一下老赵的JSCEX, 简单来说, 就是一点: 简直就是在重复发明轮子.
\r\n
有关函数式编程, 在lisp界已经有40~50年的研究, 各个方面都已经有非常完善的体系, 当然这种异步同步函数之间互相转换早已经有体系化, 可证明的研究, 实现这样一个异步类库, 最好是从底层做起, 首先实现fiber或者shift/reset这样的底层函数, 然后再其之上, 构建一个异步框架. 像老赵这样, 一上来就搞JS再编译, 那是绕了十万八千里的远路, 不仅本身会引入bug, 也会给用户的调试造成很大困扰, 性能问题也无法保证.
\r\n

","title","Call/CC与Node.js","last_reply_at","2011-11-21 12:59:57","good","top",4,"visit_count",9838,"2011-11-05 08:36:00","author",{"_13":14,"_23":24},"44","先从coroutine说起\r\n
\r\n
coroutine是一种常见的流程控制语句, 可以在单线程内模拟多线程的执行, 经常被用于非抢占式用户态纤程(Fiber)\r\n
这里先要区分一下两种不同的coroutine\r\n

stackless coroutine (semi-coroutine)

stackful coroutine (coroutine)

\r\n
stackless coroutine又经常被称为generator. 下面这些语言中的yield都属于stackless coroutine\r\n

javascript 1.7

python

ruby

\r\n
本文主要是讲解yield的本质及其实现原理, 对于yield比较陌生的同学可以先简单学习一下javascript 1.7的文档: https://developer.mozilla.org/en/New_in_JavaScript_1.7#Generators\r\n
\r\n
stackless coroutine本质上仅仅是一个语法糖, 例如下面这段javascript代码, 可以转换成不使用yield的代码:\r\n

function fib() {\r\n
  var i = 0, j = 1;\r\n
  while (true) {\r\n
    yield i;\r\n
    var t = i;\r\n
    i = j;\r\n
    j += t;\r\n
  }\r\n
}

\r\n
首先把while/for循环转换成递归, 并且新建一个generator对象:\r\n

function fib() {\r\n
  var generator = {};\r\n
  generator.next = function () {\r\n
    var i = 0, j = 1;\r\n
    var $while = function () {\r\n
      yield i;\r\n
      var t = i;\r\n
      i = j;\r\n
      j += t;\r\n
      $while();\r\n
      /* 1 */\r\n
    }\r\n
    $while();\r\n
    /* 2 */\r\n
  }\r\n
  return generator;\r\n
}

\r\n
然后对generator内部做cps变换. 经过cps变换后, yield成为一个普通函数:\r\n

function fib() {\r\n
  var generator = {};\r\n
  var $yield = function (k, value) {\r\n
    generator.next = k;\r\n
    return value;\r\n
  };\r\n
  generator.next = function () {\r\n
    var i = 0, j = 1;\r\n
    var $while = function (k /* $while never return, so k is never called. */) {\r\n
      return $yield(function () {\r\n
        // all statements after yield become continuation of yield, which comes into this function\r\n
        var t = i;\r\n
        i = j;\r\n
        j += t;\r\n
        return $while(function () { /* 1 */ });\r\n
      }, i /* arguments of yield */);\r\n
    };\r\n
    return $while(function () { /* 2 */ });\r\n
  }\r\n
  return generator;\r\n
}\r\n
\r\n
// test code, copy into any javascript engine and check result\r\n
var g = fib();\r\n
for (var i = 0; i < 10; i++) {\r\n
  console.log(g.next());\r\n
}

\r\n
上面所使用到了两种转换:\r\n

循环变递归

CPS变换

\r\n
这两种转换都是通用转换, 任何程序都可以做这样的转换, 通过这两种转换可以把任何使用yield的代码转换成普通代码. 实际上, stackless coroutine的实现就是编译器(或者解释器)在背后做了这些工作.","Javascript 1.7中的Yield","2014-11-13 02:41:51.326",23207,"2011-11-15 16:54:44",{"_13":14,"_23":24}]