poolboy简单阅读

poolboy是一个erlang编写的线程池框架，代码很简洁，项目地址：git://github.com/devinus/poolboy.git

具体用法，项目上有对应范例。

 

现在查看一下源码

首先看看初始化部分：

init({PoolArgs, WorkerArgs}) ->
    process_flag(trap_exit, true),
    Waiting = queue:new(),
    Monitors = ets:new(monitors, [private]),
    init(PoolArgs, WorkerArgs, #state{waiting = Waiting, monitors = Monitors}).

init([{worker_module, Mod} | Rest], WorkerArgs, State) when is_atom(Mod) ->
    {ok, Sup} = poolboy_sup:start_link(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([{max_overflow, MaxOverflow} | Rest], WorkerArgs, State) when is_integer(MaxOverflow) ->
    init(Rest, WorkerArgs, State#state{max_overflow = MaxOverflow});
init([_ | Rest], WorkerArgs, State) ->
    init(Rest, WorkerArgs, State);
init([], _WorkerArgs, #state{size = Size, supervisor = Sup} = State) ->
    Workers = prepopulate(Size, Sup),
    {ok, State#state{workers = Workers}}.

prepopulate(N, _Sup) when N < 1 ->
    queue:new();
prepopulate(N, Sup) ->
    prepopulate(N, Sup, queue:new()).

prepopulate(0, _Sup, Workers) ->
    Workers;
prepopulate(N, Sup, Workers) ->
    prepopulate(N-1, Sup, queue:in(new_worker(Sup), Workers)).

初始化两个队列：

1.workers队列，进程池中闲置可选择的进程队列。

2.waiting队列，当我们用阻塞方式调用checkout进程时，而这时已经没有进程可以选择时，则进入此队列中，当有进程归还时，进行处理。

初始化一个pool_sup作为supervisor，来挂接管理进程池中的每一个进程。

初始化一个私有的ets，保存调用checkout的进程，以便归还，或异常结束时候作为依据进行的资源处理。

link进程池中的每一个子进程。

 

接下来，看看checkout的操作，选择闲置进程的操作：

handle_call({checkout, Block, Timeout}, {FromPid, _} = From, State) ->
    #state{supervisor = Sup,
           workers = Workers,
           monitors = Monitors,
           overflow = Overflow,
           max_overflow = MaxOverflow} = State,
    case queue:out(Workers) of
        {{value, Pid}, Left} ->
            Ref = erlang:monitor(process, FromPid),
            true = ets:insert(Monitors, {Pid, Ref}),
            {reply, Pid, State#state{workers = Left}};
        {empty, Empty} when MaxOverflow > 0, Overflow < MaxOverflow ->
            {Pid, Ref} = new_worker(Sup, FromPid),
            true = ets:insert(Monitors, {Pid, Ref}),
            {reply, Pid, State#state{workers = Empty, overflow = Overflow + 1}};
        {empty, Empty} when Block =:= false ->
            {reply, full, State#state{workers = Empty}};
        {empty, Empty} ->
            Waiting = add_waiting(From, Timeout, State#state.waiting),
            {noreply, State#state{workers = Empty, waiting = Waiting}}
    end;

进程A调用checkout池中的闲置进程时,

    若workers队列有闲置进程可以选择，从workers队列选取进程, 同时，对进程A进行监视。

    若队列已为空，

    1. 则根据maxoverflow的限制，确定是否可以创建新的扩展进程，若没超过上限，则添加新的进程。

    2. 若已经不能进行扩展，则按照调用checkout方式进行处理，

　　　阻塞调用时候，否则，将进程A进入waiting队列，

   　　非阻塞调用时候，直接返回full。

    不管是否使用了新创建的扩展进程，如果checkout成功的时候，poolboy都会对进程A进行监视，并以{Pid, Ref}的形式插入私有ets中。以便于处理在尚没有归还进程，就出现进程A结束的情况。

 

再看看checking，归还进程的操作：

handle_cast({checkin, Pid}, State = #state{monitors = Monitors}) ->
    case ets:lookup(Monitors, Pid) of
        [{Pid, Ref}] ->
            true = erlang:demonitor(Ref),
            true = ets:delete(Monitors, Pid),
            NewState = handle_checkin(Pid, State),
            {noreply, NewState};
        [] ->
            {noreply, State}
    end;


handle_checkin(Pid, State) ->
    #state{supervisor = Sup,
           waiting = Waiting,
           monitors = Monitors,
           overflow = Overflow} = State,
    case queue:out(Waiting) of
        {{value, {{FromPid, _} = From, Timeout, StartTime}}, Left} ->
            case wait_valid(StartTime, Timeout) of
                true ->
                    Ref1 = erlang:monitor(process, FromPid),
                    true = ets:insert(Monitors, {Pid, Ref1}),
                    gen_server:reply(From, Pid),
                    State#state{waiting = Left};
                false ->
                    handle_checkin(Pid, State#state{waiting = Left})
            end;
        {empty, Empty} when Overflow > 0 ->
            ok = dismiss_worker(Sup, Pid),
            State#state{waiting = Empty, overflow = Overflow - 1};
        {empty, Empty} ->
            Workers = queue:in(Pid, State#state.workers),
            State#state{workers = Workers, waiting = Empty, overflow = 0}
    end.

假设进程A调用的checkout方法，则在checkin时候，则不再对进程A进行监视，同时销毁在ets的记录。

归还进程时候：

首先查看waiting队列是否为空，若有任务正在阻塞中，则取出，查看响应时间是否超时，若没有则返回进程，　　

若waiting队列为空，如果进程池仍然有扩展进程，则销毁该进程。以致进程池数量回复到正常的数量，否则，直接置入workers队列。

 

接下来，我们看看，当进程池中进程结束或者，或者正在调用checkout的进程结束时的处理：

handle_info({'DOWN', Ref, _, _, _}, State) ->
    case ets:match(State#state.monitors, {'$1', Ref}) of
        [[Pid]] ->
            Sup = State#state.supervisor,
            ok = supervisor:terminate_child(Sup, Pid),
            %% Don't wait for the EXIT message to come in.
            %% Deal with the worker exit right now to avoid
            %% a race condition with messages waiting in the
            %% mailbox.
            true = ets:delete(State#state.monitors, Pid),
            NewState = handle_worker_exit(Pid, State),
            {noreply, NewState};
        [] ->
            {noreply, State}
    end;
handle_info({'EXIT', Pid, _Reason}, State) ->
    #state{supervisor = Sup,
           monitors = Monitors} = State,
    case ets:lookup(Monitors, Pid) of
        [{Pid, Ref}] ->
            true = erlang:demonitor(Ref),
            true = ets:delete(Monitors, Pid),
            NewState = handle_worker_exit(Pid, State),
            {noreply, NewState};
        [] ->
            case queue:member(Pid, State#state.workers) of
                true ->
                    W = queue:filter(fun (P) -> P =/= Pid end, State#state.workers),
                    {noreply, State#state{workers = queue:in(new_worker(Sup), W)}};
                false ->
                    {noreply, State}
            end
    end;

handle_worker_exit(Pid, State) ->
    #state{supervisor = Sup,
           monitors = Monitors,
           overflow = Overflow} = State,
    case queue:out(State#state.waiting) of
        {{value, {{FromPid, _} = From, Timeout, StartTime}}, LeftWaiting} ->
            case wait_valid(StartTime, Timeout) of
                true ->
                    MonitorRef = erlang:monitor(process, FromPid),
                    NewWorker = new_worker(State#state.supervisor),
                    true = ets:insert(Monitors, {NewWorker, MonitorRef}),
                    gen_server:reply(From, NewWorker),
                    State#state{waiting = LeftWaiting};
                _ ->
                    handle_worker_exit(Pid, State#state{waiting = LeftWaiting})
            end;
        {empty, Empty} when Overflow > 0 ->
            State#state{overflow = Overflow - 1, waiting = Empty};
        {empty, Empty} ->
            Workers = queue:in(
                new_worker(Sup),
                queue:filter(fun (P) -> P =/= Pid end, State#state.workers)
            ),
            State#state{workers = Workers, waiting = Empty}
    end.

我们知道，进程池中的每个进程都已经link，所以当我们监听到'EXIT'消息，

首先判断该进程的状态

1. checkout中，则对ets中记录等进行销毁，

2. 尚在闲置中，则直接从workers进行移除。

在此之后创建一个新进程放入workers队列中。

 

当监听到一个持有闲置进程的进程结束时候，而尚未来的及向池checkin时， 除了停止supervisor管理的进程，

同时销毁私有ets中的checkout记录，清理对该进程的监视。