Restart a woker in ai_balance delay by n milliseconds

Author: DavidAlphaFox

src/pool/ai_balance.erl

@@ -25,6 +25,8 @@
     name,
     supervisor,
     size,
+    delay,
+    delay_timers,
     workers
 }).
 
@@ -65,13 +67,18 @@ start_link(Name, PoolArgs, WorkerArgs) ->
 	ignore.
 init({Name,PoolArgs, WorkerArgs})->
     process_flag(trap_exit, true),
-    init(PoolArgs,WorkerArgs,#state{name = Name}).
+    init(PoolArgs,WorkerArgs,#state{
+                                name = Name, delay = 0,
+                                delay_timers = undefined
+                               }).
 init([{worker_module, Mod} | Rest], WorkerArgs, #state{name = Name} = State) when is_atom(Mod) ->
     %% 该进程挂了，会将所有进程全部挂掉
     {ok, Sup} = ai_balance_worker_sup:start_link(Name, Mod,WorkerArgs),
     init(Rest, WorkerArgs, State#state{supervisor = Sup});
 init([{size, Size} | Rest], WorkerArgs, State) when is_integer(Size) ->
     init(Rest, WorkerArgs, State#state{size = Size});
+init([{delay,Delay} | Rest], WorkerArgs, State) when is_integer(Delay) ->
+    init(Rest, WorkerArgs, State#state{delay = Delay, delay_timers = []});
 init([_ | Rest], WorkerArgs, State) ->
     init(Rest, WorkerArgs, State);
 init([], _WorkerArgs, #state{size = Size, supervisor = Sup} = State) ->
@@ -122,15 +129,28 @@ handle_cast(_Request, State) ->
 	{noreply, NewState :: term(), hibernate} |
     {stop, Reason :: normal | term(), NewState :: term()}.
 
-handle_info({'EXIT', Pid, _Reason}, #state{supervisor = Sup} =  State) ->
+handle_info({'EXIT', Pid, _Reason}, #state{supervisor = Sup, delay = 0, workers  = Workers} =  State) ->
     case lists:member(Pid, State#state.workers) of
         true ->
-            W = lists:filter(fun (P) -> P =/= Pid end, State#state.workers),
+            W = lists:filter(fun (P) -> P =/= Pid end, Workers),
             {noreply, State#state{workers = [new_worker(Sup) | W]}};
         false ->
             {noreply, State}
     end;
-
+handle_info({'EXIT', Pid, _Reason}, #state{delay = Delay, delay_timers = Timers,
+                                           workers = Workers} =  State)->
+    case lists:member(Pid, State#state.workers) of
+        true ->
+            W = lists:filter(fun (P) -> P =/= Pid end, Workers),
+            Timer = ai_timer:start(Delay,new_worker,ai_timer:new([async])),
+            {noreply, State#state{workers = W, delay_timers = [Timer | Timers]}};
+        false ->
+            {noreply, State}
+    end;
+handle_info({timeout,TimerRef,new_worker},#state{supervisor = Sup, delay_timers = Timers,
+                                                workers = Workers} = State)->
+    Timers1 = lists:filter(fun(T)-> ai_timer:is_current(TimerRef,T) =/= true end,Timers),
+    {noreply, State#state{workers = [new_worker(Sup)| Workers], delay_timers = Timers1}};
 handle_info(_Info, State) ->
 	{noreply, State}.
 

src/stdlib/ai_timer.erl

@@ -4,15 +4,23 @@
 -export([is_current/2,is_previous/2]).
 
 
--record(ai_timer,{timeout,msg,prev_ref,ref,async,info}).
+-record(ai_timer,{
+                  timeout,
+                  msg,
+                  prev_ref,
+                  ref,
+                  async,
+                  info,
+                  abs}).
 
 new()-> #ai_timer{timeout = infinity,msg = undefined,prev_ref = undefined,
-                    ref = undefined,async = false,info = false}.
+                    ref = undefined,async = false,info = false,abs = false}.
 new(Opts) ->
     Timer =  new(),
     lists:foldl(fun(I,Acc)->
         if  I == info -> Acc#ai_timer{info = true};
             I == async -> Acc#ai_timer{async = true};
+            I == abs -> Acc#ai_timer{abs = true};
             true -> Acc
         end
     end,Timer,Opts).
@@ -25,9 +33,9 @@ cancel_internal(#ai_timer{async = Async,info = Info,ref = Ref} = Timer )->
             Timer#ai_timer{prev_ref = Ref,ref = undefined}
     end.
 
-start_internal(Timeout,TimeoutMsg,Timer)->
+start_internal(Timeout,TimeoutMsg,#ai_timer{ abs = ABS } = Timer)->
     Timer1 = cancel_internal(Timer),
-    Ref = erlang:start_timer(Timeout, self(), TimeoutMsg),
+    Ref = erlang:start_timer(Timeout, self(), TimeoutMsg,[{abs,ABS}]),
     Timer1#ai_timer{timeout = Timeout,msg = TimeoutMsg,ref = Ref}.
 
 check_rule(Timeout,TimeoutMsg)->
@@ -53,4 +61,4 @@ cancel( Timer)-> cancel_internal(Timer).
 
 is_current(Ref,#ai_timer{ref = TRef}) -> Ref == TRef.
 
-is_previous(Ref,#ai_timer{prev_ref = TRef}) ->  Ref == TRef.
+is_previous(Ref,#ai_timer{prev_ref = TRef}) ->  Ref == TRef.