Ordnungsgemäße Methode zum Strukturieren von GenServer-Aufrufe an self

Question

Ich weiß, dass es ziemlich unmöglich ist, dass ein GenServer-Prozess sich selbst aufruft, weil Sie im Wesentlichen einen Deadlock haben. Aber ich bin neugierig, ob es einen bevorzugten Weg gibt, so etwas zu tun.

Angenommen, das folgende Szenario: Ich habe eine Warteschlange, aus der ich Sachen herauspoppe. Wenn die Warteschlange jemals leer ist, möchte ich sie wieder auffüllen. Ich könnte es so strukturieren:

def handle_call(:refill_queue, state) do 
    new_state = put_some_stuff_in_queue(state) 
    {:reply, new_state} 
end 

def handle_call(:pop, state) do 
    if is_empty_queue(state) do 
    GenServer.call(self, :refill_queue) 
    end 

    val,new_state = pop_something(state) 

    {:reply, val, new_state} 
end 

Das große Problem hier ist, dass dies Deadlock wird, wenn wir versuchen, die Warteschlange aufzufüllen. Eine Lösung, die ich in der Vergangenheit verwendet habe, ist die Verwendung von cast mehr, damit es nicht blockiert. Wie so (call für Nachfüllung cast ändern)

def handle_cast(:refill_queue, state) do 

Aber in diesem Fall, ich denke, es wird nicht funktionieren, da die Asynchron-Guss die Warteschlange zum Nachfüllen im pop Fall zurückkehren könnte, bevor sie tatsächlich die Warteschlange Bedeutung Füllung Ich werde versuchen, eine leere Warteschlange zu löschen. Die Kernfrage ist: Wie ist der beste Weg, damit umzugehen? Ich nehme an, die Antwort ist nur put_some_stuff_in_queue direkt innerhalb der pop Anruf anrufen, aber ich wollte überprüfen. Mit anderen Worten, es scheint, als ob das Richtige zu tun ist, machen handle_call und handle_cast so einfach wie möglich und im Grunde nur Wrapper zu anderen Funktionen, wo die eigentliche Arbeit passiert. Dann erstellen Sie so viele handle_* Funktionen, wie Sie alle möglichen Fälle abdecken müssen, mit denen Sie beschäftigen werden, anstatt handle_call(:foo) wiederum handle_call(:bar) anrufen.

Answer 1

Es gibt eine Funktion in GenServer Modul namens reply/2. Das zweite Argument des Callbacks handle_call/3 ist die Verbindung zum Client. Sie können einen neuen Prozess zur Verarbeitung der Verbindung erstellen und {:noreply, state} in der Callback-Klausel zurückgeben. Mit Ihrem Beispiel:

defmodule Q do 
    use GenServer 

    ############ 
    # Public API 

    def start_link do 
    GenServer.start_link(__MODULE__, []) 
    end 

    def push(pid, x) do 
    GenServer.call(pid, {:push, x}) 
    end 

    def pop(pid) do 
    GenServer.call(pid, :pop) 
    end 

    ######## 
    # Helper 

    # Creates a new process and does a request to 
    # itself with the message `:refill`. Replies 
    # to the client using `from`. 
    defp refill(from) do 
    pid = self() 
    spawn_link fn -> 
     result = GenServer.call(pid, :refill) 
     GenServer.reply(from, result) 
    end 
    end 

    ########## 
    # Callback 

    def handle_call(:refill, _from, []) do 
    {:reply, 1, [2, 3]} 
    end 
    def handle_call(:refill, _from, [x | xs]) do 
    {:reply, x, xs} 
    end 
    def handle_call({:push, x}, _from, xs) when is_list(xs) do 
    {:reply, :ok, [x | xs]} 
    end 
    def handle_call(:pop, from, []) do 
    # Handles refill and the reply to from. 
    refill(from) 
    # Returns nothing to the client, but unblocks the 
    # server to get more requests. 
    {:noreply, []} 
    end 
    def handle_call(:pop, _from, [x | xs]) do 
    {:reply, x, xs} 
    end 
end 

Und Sie würden das folgende erhalten:

iex(1)> {:ok, pid} = Q.start_link() 
{:ok, #PID<0.193.0>} 
iex(2)> Q.pop(pid) 
1 
iex(3)> Q.pop(pid) 
2 
iex(4)> Q.pop(pid) 
3 
iex(5)> Q.pop(pid) 
1 
iex(6)> Q.pop(pid) 
2 
iex(7)> Q.pop(pid) 
3 
iex(8)> Q.push(pid, 4) 
:ok 
iex(9)> Q.pop(pid)  
4 
iex(10)> Q.pop(pid) 
1 
iex(11)> Q.pop(pid) 
2 
iex(12)> Q.pop(pid) 
3 
iex(13)> tasks = for i <- 1..10 do 
...(13)> Task.async(fn -> {"Process #{inspect i}", Q.pop(pid)} end) 
...(13)> end 
(...) 
iex(14)> for task <- tasks, do: Task.await(task) 
[{"Process 1", 1}, {"Process 2", 2}, {"Process 3", 1}, {"Process 4", 2}, 
{"Process 5", 3}, {"Process 6", 3}, {"Process 7", 2}, {"Process 8", 1}, 
{"Process 9", 1}, {"Process 10", 3}] 

So ist es in der Tat möglich, dass ein GenServer Anforderungen an sich selbst zu tun. Du musst nur wissen wie.

Ich hoffe, das hilft.

Answer 2

Warum müssen Sie GenServer.call machen?

def handle_call(:pop, state) do 
    new_state0 = if is_empty_queue(state) do 
    put_some_stuff_in_queue(state) 
    else 
    state 
    end 
    {val,new_state} = pop_something(new_state0) 

    {:reply, val, new_state} 
end 

oder

def handle_call(:pop, state) do 
    {val, new_state} = state 
        |> is_empty_queue 
        |> case do 
          true -> 
          put_some_stuff_in_queue(state) 
          false -> 
          state 
         end 
        |> pop_something 

    {:reply, val, new_state} 
end 

so Telefonieren ist tabu, sondern auch andere Funktionen aufrufen völlig machbar ist.