Lwt.async 和 Lwt_main.run 在 OCaml/Node.JS 上有什么区别?

Question

我正在试验js_of_ocaml和node.js。如您所知，node.js 广泛使用回调来实现异步请求，而无需引入显式线程。

在OCaml中，我们有一个非常好的线程库Lwt，带有一个非常有用的语法扩展。我编写了一个绑定到某个节点库（AWS S3 客户端）的原型，并添加了一个 lwt-ish 层来隐藏回调。

open Lwt.Infix
open Printf
open Js
let require_module s =
    Js.Unsafe.fun_call
      (Js.Unsafe.js_expr "require")
      [|Js.Unsafe.inject (Js.string s)|]
let _js_aws = require_module "aws-sdk"
let array_to_list a =
  let ax = ref [] in
  begin
    for i = 0 to a##.length - 1 do
      Optdef.iter (array_get a i) (fun x -> ax := x :: !ax)
    done;
    !ax
  end

class type error = object
end
class type bucket = object
  method _Name : js_string t readonly_prop
  method _CreationDate : date t readonly_prop
end
class type listBucketsData = object
  method _Buckets : (bucket t) js_array t readonly_prop
end
class type s3 = object
  method listBuckets :
    (error -> listBucketsData t -> unit) callback -> unit meth
end
let createClient : unit -> s3 t = fun () ->
  let constr_s3 = _js_aws##.S3 in
  new%js constr_s3 ()

module S3 : sig
  type t
  val create : unit -> t
  val list_buckets : t -> (string * string) list Lwt.t
end = struct
  type t = s3 Js.t
  let create () =
    createClient ()
  let list_buckets client =
    let cell_of_bucket_data data =
      ((to_string data##._Name),
       (to_string data##._CreationDate##toString))
    in
    let mvar = Lwt_mvar.create_empty () in
    let callback error buckets =
      let p () =
        if true then
          Lwt_mvar.put mvar
            (`Ok(List.map cell_of_bucket_data @@ array_to_list buckets##._Buckets))
        else
          Lwt_mvar.put mvar (`Error("Ups"))
      in
      Lwt.async p
    in
    begin
      client##listBuckets (wrap_callback callback);
      Lwt.bind
        (Lwt_mvar.take mvar)
        (function
          | `Ok(whatever) -> Lwt.return whatever
          | `Error(mesg) -> Lwt.fail_with mesg)
    end
end
let () =
  let s3 = S3.create() in
  let dump lst =
    Lwt_list.iter_s
      (fun (name, creation_date) ->
         printf "%32st%sn" name creation_date;
         Lwt.return_unit)
      lst
  in
  let t () =
    S3.list_buckets s3
    >>= dump
  in
  begin
    Lwt.async t
  end

由于 node.js 没有绑定到 Lwt_main，我不得不使用 Lwt.async 运行我的代码。使用 Lwt.async 而不是使用 Lwt_main.run 运行代码有什么区别——后者在 node.js 中不存在？ 是否可以保证程序将等到异步线程完成后再退出，或者这是我的代码的幸运但随机的行为？

Answer 1

Lwt_main.run 函数递归轮询它监督其执行的线程。 在每次迭代中，如果此线程仍在运行，调度程序将使用一个引擎（从 Lwt_engine 开始）通过选择或同步事件来执行等待 I/O 的线程。

在 Node.JS 中转换它的自然方法是使用 process.nextTick 方法，该方法依赖于 Node 自己的调度程序.JS。 在这种情况下，实现Lwt_main.run函数可以像以下那样简单：

let next_tick (callback : unit -> unit) =
  Js.Unsafe.(fun_call
               (js_expr "process.nextTick")
               [| inject (Js.wrap_callback callback) |])
let rec run t =
  Lwt.wakeup_paused ();
  match Lwt.poll t with
    | Some x -> x
    | None -> next_tick (fun () -> run t)

此函数仅运行 unit Lwt.t 类型的线程，但这是程序的主要情况。 可以使用通信Lwt_mvar.t计算任意值。

也可以扩展此示例以支持所有类型的钩子，就像在原始Lwt_main.run实现中一样。