anchor.diff:  init(Options) ->
       Q = #q{
           max_size = couch_util:get_value(max_size, Options),
  -        max_items = couch_util:get_value(max_items, Options)
  +        max_items = couch_util:get_value(max_items, Options),
  +        multi_workers = couch_util:get_value(multi_workers, Options, false)
       },
       {ok, Q}.
   
  -terminate(_Reason, #q{work_waiter=nil}) ->
  -    ok;
  -terminate(_Reason, #q{work_waiter={WWFrom, _}}) ->
  -    gen_server:reply(WWFrom, closed).
  +terminate(_Reason, #q{work_waiters=Workers}) ->
  +    lists:foreach(fun({W, _}) -> gen_server:reply(W, closed) end, Workers).
       
  -handle_call({queue, Item}, From, #q{work_waiter=nil}=Q0) ->
  +handle_call({queue, Item}, From, #q{work_waiters=[]}=Q0) ->
       Q = Q0#q{size=Q0#q.size + byte_size(term_to_binary(Item)),
                   items=Q0#q.items + 1,
                   queue=queue:in(Item, Q0#q.queue)},
  
positive.code:     false ->
          {reply, ok, Q}
      end;
  handle_call({queue, Item}, _From, #q{work_waiter={WWFrom, _Max}}=Q) ->
      gen_server:reply(WWFrom, {ok, [Item]}),
      {reply, ok, Q#q{work_waiter=nil}};
  handle_call({dequeue, _Max}, _From, #q{work_waiter=WW}) when WW /= nil ->
      exit("Only one caller allowed to wait for work at a time");
  handle_call({dequeue, Max}, From, #q{items=0}=Q) ->
      {noreply, Q#q{work_waiter={From, Max}}};
  handle_call({dequeue, Max}, _From, #q{queue=Queue, max_size=MaxSize,
          max_items=MaxItems, items=Items,close_on_dequeue=Close}=Q) ->
      if Max >= Items orelse Max == all ->
          [gen_server:reply(From, ok) || From <- Q#q.blocked],
          Q2 = #q{max_size=MaxSize, max_items=MaxItems},
          if Close ->
              {stop, normal, {ok, queue:to_list(Queue)}, Q2};
          true ->
              {reply, {ok, queue:to_list(Queue)}, Q2}
          end;
      true ->
          {DequeuedItems, Queue2, Blocked2} =
                  dequeue_items(Max, Queue, Q#q.blocked, []),
          {reply, {ok, DequeuedItems},
                  Q#q{items=Items-Max,blocked=Blocked2,queue=Queue2}}
      end.
  
  dequeue_items(0, Queue, Blocked, DequeuedAcc) ->
  
negative.code:     max_items,
      items=0,
      size=0,
      work_waiters=[],
      close_on_dequeue=false,
      multi_workers=false
  }).
  
  new(Options) ->
  