Vermeiden einer Wettlaufsituation

Question

Das folgende Codefragment ist Seite 112 des Buches von Francesco Cesarini und Simon Thompson, Erlang Programming, zur Illustration einer möglichen Wettlaufsituation in Erlang entnommen.

start() -> 
    case whereis(db_server) of 
    undefined -> 
     Pid = spawn(db_server, init, []), 
     register(db_server, Pid), 
     {ok, Pid}; 
    Pid when is_pid(Pid) -> 
     {error, already_started} 
    end. 

Ohne die Details wörtlich zu kopieren, erklären die Autoren, dass, wenn zwei Prozesse gleichzeitig start() ausführen, dann 1 verarbeiten möglicherweise nicht abgeschlossen, die „undefiniert“ Abschnitt ausgeführt wird, weil Prozess 2 verursacht es vorbelegt werden. Der Prozess 2 würde dann den "undefinierten" Abschnitt zum Abschluss bringen. Jetzt, wenn Prozess 1 fortgesetzt wird, wurde db_server bereits von Prozess 2 registriert, wodurch der Aufruf von register() einen Laufzeitfehler auslöst. Ich hoffe du verstehst was ich meine, weil ich den Text des Buches nicht filtrieren will.

Meine Frage ist, wie kann die obige genaue Funktionalität codiert werden, um die mögliche Race Condition zu vermeiden, wenn zwei Prozesse gleichzeitig starten()?

Answer 1

Wie viele Server möchten Sie starten? Ihre ursprüngliche Frage impliziert eine, während ein Kommentar zu @cthulahoops zwei sagt, ein Server und ein Backup. Für zwei Server könnten Sie etwas versuchen wie:

start() -> 
    case whereis(db_server) of 
     undefined -> 
      Spid = spawn(db_server, init, []), 
      %% In race condition there can be only one that succeeds to register 
      case catch register(db_server, Spid) of 
       true -> {ok,Spid};    %We are it 
       {error,_} ->     %Server registered, register as backup 
        register(db_server_backup, Spid), 
        {ok,Spid} 
      end; 
     _ ->         %Server registered, start backup 
      Bpid = spawn(db_server, init, []), 
      register(db_server_backup, Bpid), 
      {ok,Bpid} 
    end. 

Ich habe es noch nicht ausgeführt.

Answer 2

Sie könnten eine gen_server verwenden, um die Anfragen zu serialisieren.

Answer 3

Im Allgemeinen wird dies dadurch gelöst, dass der erzeugte Prozess seinen eigenen Namen registriert und dann eine Antwort an seinen Elternteil zurücksendet, die dem Elternteil mitteilt, ob es erfolgreich war oder nicht.

start() -> 
    Pid = spawn(db_server, init, [self()]), 
    receive {Pid, StartResult} -> 
     StartResult 
    end. 

init(Parent) -> 
    try register(db_server, self()) of 
     true -> 
      Parent ! {ok, started}, 
      real_init() 
    catch error:_ -> 
     Parent ! {error, already_started} 
    end. 

(Mai kompiliert oder Arbeit nicht. Hier typisiert, ohne zu überprüfen. :))

Sie können eine sorgfältig umgesetzt Version davon in gen.erl finden. In der Praxis verwenden Sie in echtem Code nur das OTP-Verhalten, um diese Version wiederzuverwenden.