Question

我需要维护一个共享队列，我可以在其中推送数据，如果非空，则需要一个单独的线程定期检查并从队列中提取数据。我想出了下面的解决方案，我可以将数据发送到流程，并将其添加到列表中。但是，有更清洁/更容易的解决方案吗？

我不知道如何从下面的代码中提取数据。

-module(abc).
-export(queue/0).
queue() ->
    receive
        {push, Xmpp} ->
            io:format("Push"),
            queue(Xmpp);
        {pull} ->
            io:format("pull"),
            queue()
    end.

queue(E) ->
    receive
        {push, Xmpp} ->
            io:format("Push ~w",[E]),
            E1 = lists:append([E],[Xmpp]),
            queue(E1);
        {reset} ->
            queue([])
    end.

Answer 1

代码可能不会完全按照您的要求完成。当您从queue/1块（第7行receive）致电queue(Xmpp);时，queue/1将会触发，然后等待消息。因为这不是在单独的进程中生成的，所以queue/0将阻止（因为queue/1现在正在等待从未发送的消息）。

此外，queue/0无法向发送消息的进程发回任何内容。它无法将数据返回给发件人。

以下内容适用（您需要将消息发送到queue/0返回的pid。）

-module(abc).
-export([queue/0,queue/1]).

queue() ->
    %% initialize an empty queue,
    %% return the Pid to the caller
    spawn(abc,queue,[[]]).




queue(E) when is_list(E) ->
    receive
        %% append the message value to the existing list
        {push, Xmpp} ->
            io:format("Pushing ~w to ~w~n",[Xmpp,E]),
            E1 = lists:append(E,[Xmpp]),
            queue(E1);

        %% reset the queue
        {reset} ->
            queue([]);

        %% return the value to the caller
        %% "Pid" must be a Pid
        {pull, Pid} when is_pid(Pid) ->
            io:format("pull~n"),
            Pid ! E,
            queue(E)
    end.

Answer 2

这是Erlang中直接解决方案的问题。大多数情况下，您将编程的每个erlang模块都将像服务器一样，它将支持消息并将回答，您可以拥有运行相同erlang模块代码的0,1或多个服务器。同时，你将在同一个模块中编程一个客户端，这是一种向服务器发送消息的简单方法，而不必知道服务器期望的所有消息格式，而是你使用函数，所以不要做像

Server ! {put, Value},
receive 
    {Server, {ok, Value}} ->
        everything_ok;
    {Server, {error, Reason}} ->
        handle_error
end,

你结束了像

这样的事情

my_module:put(Server, Value).

因此，您可以使用代码

在erlang中创建服务器进程

-module(abc).
-export([start/0, put/2, pop/1, reset/1, is_empty/1, loop/1]).

%% Client

start() ->
    spawn(?MODULE, loop, [[]]).

put(Pid, Item) ->
    Pid ! {self(), {put, Item}},
    receive
        {Pid, {ok, Item}} ->
            Item;
        {Pid, {error, Reason}} ->
            {error, Reason}
    after 500 ->
            timeout
    end.

pop(Pid) ->
    Pid ! {self(), {pop}},
    receive
        {Pid, {ok, Item}} ->
            Item;
        {Pid, {error, Reason}} ->
            {error, Reason}
    after 500 ->
            timeout
    end.

reset(Pid) ->
    Pid ! {self(), {reset}},
    receive
        {Pid, {ok}} ->
            ok;
        _ ->
            error
    after 500 ->
            timeout
    end.

is_empty(Pid) ->
    Pid ! {self(), {is_empty}},
    receive
        {Pid, {true}} ->
            true;
        {Pid, {false}} ->
            false;
        _ ->
            error
    after 500 ->
            timeout
    end.

%% Server

loop(Queue) ->
    receive
        {From, {put, Item}} when is_pid(From) ->      
            From ! {self(), {ok, Item}},
            loop(Queue ++ [Item]);
        {From, {pop}} when is_pid(From) ->
            case Queue of
                [] -> 
                    From ! {self(), {error, empty}},
                    loop(Queue);
                [H|T] ->
                    From ! {self(), {ok, H}},
                    loop(T)
            end;
        {From, {reset}} when is_pid(From) ->
            From ! {self(), {ok}},
            loop([]);
        {From, {is_empty}} when is_pid(From) ->
            case Queue of
                [] ->
                    From ! {self(), {true}},
                    loop(Queue);
                _ ->
                    From ! {self(), {false}},
                    loop(Queue)
            end;
        _ ->
            loop(Queue)
    end.

并且您要使用的代码也很简单：

(emacs@rorra)1> c("/Users/rorra/abc", [{outdir, "/Users/rorra/"}]).     
{ok,abc}      

(emacs@rorra)2> Q = abc:start().       
<0.44.0>

(emacs@rorra)3> abc:is_empty(Q).       
true

(emacs@rorra)4> abc:pop(Q).       
{error,empty}

(emacs@rorra)5> abc:put(Q, 23).       
23

(emacs@rorra)6> abc:is_empty(Q).       
false

(emacs@rorra)7> abc:pop(Q).       
23

(emacs@rorra)8> abc:pop(Q).       
{error,empty}

(emacs@rorra)9> abc:put(Q, 23).       
23

(emacs@rorra)10> abc:put(Q, 50).       
50

(emacs@rorra)11> abc:reset(Q).       
ok

(emacs@rorra)12> abc:is_empty(Q).       
true

最后为了避免所有重复的代码，你使用OTP结束并为它编写gen_server。

我假设您正在自己构建一个队列进行学习，否则Erlang已经有了很好的队列实现：

http://www.erlang.org/doc/man/queue.html

源代码：

https://github.com/erlang/otp/blob/master/lib/stdlib/src/queue.erl

Erlang：从共享队列中推送和拉出

2 个答案: