Question

我在SML/NJ REPL中运行了一个最小的TCP服务器，我想知道如何在键盘中断上优雅地关闭监听器套接字。

是服务器的精简版本

fun sendHello sock = 
    let val res = "HTTP/1.1 200 OK\r\nContent-Length: 12\r\n\r\nHello world!\r\n\r\n"
        val slc = Word8VectorSlice.full (Byte.stringToBytes res)
    in 
      Socket.sendVec (sock, slc);
      Socket.close sock
    end

fun acceptLoop serv =
    let val (s, _) = Socket.accept serv
    in print "Accepted a connection...\n";
       sendHello s;
       acceptLoop serv
    end

fun serve port =
    let val s = INetSock.TCP.socket()
    in Socket.Ctl.setREUSEADDR (s, true);
       Socket.bind(s, INetSock.any port);
       Socket.listen(s, 5);
       print "Entering accept loop...\n";
       acceptLoop s
    end

问题是，如果我启动此服务器侦听端口，使用键盘中断取消，然后尝试在同一端口重新启动，我收到错误。

Standard ML of New Jersey v110.76 [built: Thu Feb 19 00:37:13 2015]
- use "test.sml" ;;
[opening test.sml]
[autoloading]
[library $SMLNJ-BASIS/basis.cm is stable]
[autoloading done]
val sendHello = fn : ('a,Socket.active Socket.stream) Socket.sock -> unit
val acceptLoop = fn : ('a,Socket.passive Socket.stream) Socket.sock -> 'b
val serve = fn : int -> 'a
val it = () : unit
- serve 8181 ;;
stdIn:2.1-2.11 Warning: type vars not generalized because of
   value restriction are instantiated to dummy types (X1,X2,...)
Entering accept loop...
Accepted a connection...
  C-c C-c
Interrupt
- serve 8181 ;;
stdIn:1.2-1.12 Warning: type vars not generalized because of
   value restriction are instantiated to dummy types (X1,X2,...)

uncaught exception SysErr [SysErr: Address already in use [<UNKNOWN>]]
  raised at: <bind.c>
-

因此，当发生某些错误时，我希望能够关闭侦听套接字。当我发出键盘中断时，我在REPL中看到Interrupt，所以我假设Interrupt是我期望捕获的异常的构造函数。但是，向handle或acceptLoop添加适当的serve行似乎无法满足我的需求。

fun acceptLoop serv =
    let val (s, _) = Socket.accept serv
    in print "Accepted a connection...\n";
       sendHello s;
       acceptLoop serv
    end
    handle Interrupt => Socket.close serv

fun serve port =
    let val s = INetSock.TCP.socket()
    in Socket.Ctl.setREUSEADDR (s, true);
       Socket.bind(s, INetSock.any port);
       Socket.listen(s, 5);
       print "Entering accept loop...\n";
       acceptLoop s
       handle Interrupt => Socket.close s
    end

（然后在REPL中）

- use "test.sml" ;;
[opening test.sml]
val sendHello = fn : ('a,Socket.active Socket.stream) Socket.sock -> unit
val acceptLoop = fn : ('a,Socket.passive Socket.stream) Socket.sock -> 'b
val serve = fn : int -> 'a
val it = () : unit
- serve 8182 ;;
stdIn:3.1-3.11 Warning: type vars not generalized because of
   value restriction are instantiated to dummy types (X1,X2,...)
Entering accept loop...
Accepted a connection...
  C-c C-c
Interrupt
- serve 8182 ;;
stdIn:1.2-1.12 Warning: type vars not generalized because of
   value restriction are instantiated to dummy types (X1,X2,...)

uncaught exception SysErr [SysErr: Address already in use [<UNKNOWN>]]
  raised at: <bind.c>
-

对变量（handle x => (Socket.close s; raise x)）或通配符（handle _ => Socket.close s）异常匹配执行相同操作具有与上述相同的效果。

Answer 1

您对标准ML本身有很大的限制，这就是标准语言没有为并发编程做出任何规定。在这种特殊情况下你需要并发。

幸运的是，您正在使用SML / NJ，它有一些允许并发支持的扩展 - continuations。

在SML / NJ中，你可以install an interrupt handler然后恢复你想要的任何程序继续。以下是serve函数的外观（当我在SML / NJ中进行延续时，我自己是初学者，所以这更像是一个暗示，而不是＆＃34;这是你是怎么做的＆＃34;例子）：

fun serve port =
  (*
   * Capture the current continuation, which is basically the next REPL
   * prompt after the server is done accepting requests.
   *)
  SMLofNJ.Cont.callcc (fn serverShutdownCont =>
    let
      val s = INetSock.TCP.socket()

      (*
       * The interrupt handler that is called when ^C is pressed.
       * Shuts down the server and returns the continuation that should
       * be resumed next, i.e. `serverShutdownCont`.
       *)
      fun interruptHandler (signal, n, cont) =
        let in
          print "Shutting down server... "
        ; Socket.close s
        ; print "done.\n"
        ; serverShutdownCont
        end
    in
      (* Register the interrupt handler. *)
      Signals.setHandler (Signals.sigINT, Signals.HANDLER interruptHandler);
      Socket.Ctl.setREUSEADDR (s, true);
      Socket.bind(s, INetSock.any port);
      Socket.listen(s, 5);
      print "Entering accept loop...\n";
      acceptLoop s
    end)

有一个非常好的资源可以找到更多关于这一点的Unix System Programming with Standard ML，其中开发了一个小型Web服务器，因此您可能会发现它非常有用。

接下来的另一件事是接受循环中的并发性。现在，您的程序一次只能处理一个HTTP请求。如果你想一次支持更多，不一定是并行，但至少同时（交错），那么你必须研究Concurrent ML (CML)，这是标准ML的并发扩展，实现为在SML / NJ提供的延续之上的库。 CML随SML / NJ一起提供。

由图书馆的作者John Reppy编写的关于CML的非常好的教程是Concurrent Programming in ML。我最近完成了本书的第一部分，并且它已经得到了彻底的解释。

处理键盘中断

1 个答案: