如果使用start_link，您将看到端口在第一个命令之后崩溃：

1> port:start('go run port.go').
<0.118.0>
2> port:ping(65000).
65000
** exception error: port_terminated

如果你把Go代码改为在循环中运行，就可以避免这种崩溃：

func main() {
    for {
        // reader := bufio:NewReader(os.Stdin)
        reader := bufio.NewReaderSize(os.Stdin, 1677216) // 2**24;
        bytes, _ := reader.ReadBytes(Delimiter)
        os.Stdout.Write(bytes[:len(bytes)-1])
    }
}

现在我们可以看到另一个有趣的结果：

33> c(port).
{ok,port}
40> port:ping(66000).
65536
41> port:ping(66000).
464
42> port:ping(66000).
65536
43> port:ping(66000).
464

现在我们可以看到实际上没有数据丢失，数据只是在端口中缓冲。由于您没有指定帧协议（使用{packet, N}或{line, N}），您自己负责收集数据。Erlang端口的内部缓冲区大小似乎是64K（尽管我没有找到相关文档，也没有办法更改它）。
如果你改变你的receive以在返回之前获取所有数据，你将每一次每一个字节：

loop(Port) ->
    receive
    {call, Caller, Msg} ->
        Port ! {self(), {command, Msg++?DELIMITER}},
        Caller ! {myname, receive_all(Port, 10)},
        loop(Port);
    stop ->
        Port ! {self(), close},
        receive
        {Port, closed} ->
            exit(normal)
        end;
    {'EXIT', Port, _Reason} ->
        exit(port_terminated)
    end.

receive_all(Port, Timeout) -> receive_all(Port, Timeout, []).

receive_all(Port, Timeout, Data) ->
    receive
    {Port, {data, New}} ->
        receive_all(Port, Timeout, [New|Data])
    after Timeout ->
        lists:flatten(lists:reverse(Data))
    end.

运行该程序，我们得到：

1> c(port).
{ok,port}
2>
3> port:start('go run port.go').
<0.311.0>
4> port:ping(66000).
66000
5> port:ping(66000).
66000
6> port:ping(66000).
66000

1. 2^8 is 256, not 65536 which is 2^16 (or 2 bytes).
2. For excluding golang program you can simply replace your echo with GNU cat
3. Default message max size for port communication is 64k, so when your port receives messages, the first one is leading 64k of the string. You can read port again to gain remaining data but you just drop them in your code.
4. If you really want to communicate on line-based protocol you should configure your port accordingly:
   {line, L}
   Messages are delivered on a per line basis. Each line (delimited by the OS-dependent newline sequence) is delivered in one single message. The message data format is {Flag, Line}, where Flag is either eol or noeol and Line is the actual data delivered (without the newline sequence).
   L specifies the maximum line length in bytes. Lines longer than this will be delivered in more than one message, with the Flag set to noeol for all but the last message. If end of file is encountered anywhere else than immediately following a newline sequence, the last line will also be delivered with the Flag set to noeol. In all other cases, lines are delivered with Flag set to eol.
   The {packet, N} and {line, L} settings are mutually exclusive.
   So your code would be

Port = open_port({spawn, ExtPrg}, [{line, ?PACKET_SIZE]),
%%...
{call, Caller, Msg} ->
    Port ! {self(), {command, Msg++?DELIMITER}},
    D = read_data(Port, []),
    Caller ! {myname, D},
    loop(Port);
%%...
read_data(Port, Prefix) ->
receive
    {Port, {data, {noeol, Data}}} ->
        read_data(Port, Prefix ++ Data);
    {Port, {data, {eol, Data}}} ->
        Prefix ++ Data
end.

我一直在努力解决类似的问题。这里是管道模块的完整代码。
它允许向端口发送文本数据并读取所有回复。

-module(apr_pipe).

-export([open_pipe/2,send/2,close/1]).

-export([loop/1,status/1,init/1]).

-include_lib("kernel/include/logger.hrl").

-define(MAX_LINE_LEN,4096).

open_pipe(Path,Cmd) ->
   State = #{path => Path, cmd => Cmd},
    Pid = spawn(?MODULE,init,[State]),
    Pid.

init(State) ->
    #{path := Path,cmd := Cmd} = State,
    FullFn = filename:join(Path,Cmd),
    Settings = [{line,?MAX_LINE_LEN},use_stdio,stderr_to_stdout,hide,binary,exit_status],
    Port = erlang:open_port({spawn_executable,FullFn},Settings),
    State2 = State#{port => Port, data => #{}},
    loop(State2).

send(Pid,Data)  -> Pid!{self(),send,Data}.
close(Pid)      -> Pid!{self(),send,close}.
status(Pid)     -> Pid!{self(),status}.

get_eol() -> <<"\n">>.

loop(State) ->
    receive
        {_Pid,send,close} -> 
                    ?LOG(notice,"got cmd: Close",[]),
                    Port = maps:get(port,State),
                    port_close(Port),
                    exit(normal);
        {Pid,send,Data} ->
                    ?LOG(notice,"Send Data ...",[]),
                    Port = maps:get(port,State),
                    port_command(Port,Data),
                    port_command(Port,get_eol()),
                    State2 = State#{status => data_sent, client => Pid},
                    loop(State2);
         {Pid,status} -> 
                    Port = maps:get(port,State),
                    ?LOG(notice,"Status: Port: ~p State: ~p",[Port,State]),
                    Pid!{status,Port,State},
                    loop(State);
        % port messages.
        {Port, {data,{noeol,Data}}} ->
                ?LOG(notice,"Port: ~p Data: ~p",[Port,Data]),
                CurData = maps:get(cur_data,State,[]),
                State2 = State#{cur_data => [Data | CurData]},
                loop(State2);

        {Port, {data, {eol,Data}}} ->
                ?LOG(notice,"Port: ~p Data: ~p",[Port,Data]),
                CurData = [Data | maps:get(cur_data,State,[])],
                CurData2 = lists:reverse(CurData),
                Reply    = list_to_binary(CurData2),
                Client = maps:get(client,State,undefined),
                State2 = State#{cur_data => [], client => undefined},
                case Client of
                    undefined -> ?LOG(error,"can not sent reply. Client: ~p Reply: ~p", [Client,Reply]),
                                 loop(State2);
                    _ -> Client!{reply,Reply},
                         loop(State2)
                 end;
        {_Port, closed} ->
                ?LOG(warning, "Port: ~p closed",[]),
                exit(normal);
        {'EXIT',  Port, Reason} ->
                 ?LOG(notice,"Port: ~p exit. Reason: ~p",[Port,Reason]),
                 exit(Reason);
        _Other -> ?LOG(error,"unexpected message: ~p",[_Other]),
                  exit({error,{unexpected_message,_Other}})
    end.