There are no calls to this function for `lock` resources, so processes blocked waiting for locks, do so indefinitely.

Running `block_simple()` below you will never see the output from P2.

```erlang
block_simple() ->
    {ok, S1} = riak_core_table_manager:start_link([{background_mgr_table, 
                                                   [protected, named_table, bag]}]),
    {ok, S2} = riak_core_bg_manager:start_link(),
    unlink(S1),
    unlink(S2),
    riak_core_bg_manager:set_concurrency_limit(a, 1),
    P1 = spawn(fun() ->
                       riak_core_bg_manager:get_lock_blocking(a, 10000),
                       io:format("P1: Got Lock, Waiting to Die~n"),
                       receive kill -> io:format("P1: I'm Dead~n") end
               end),
    P2 = spawn(fun() ->
                       timer:sleep(1000),
                       case riak_core_bg_manager:get_lock_blocking(a, 1000000) of
                           ok ->
                               io:format("P2: Got Lock, Waiting to Die~n"),
                               receive kill -> io:format("P2: I'm Dead~n") end;
                           timeout ->
                               io:format("P2: Timed out waiting for kill~n")
                       end
               end),
    io:format("P1: ~p, P2: ~p~n", [P1, P2]),
    timer:sleep(2000),
    P1 ! kill,
    timer:sleep(10000),
    io:format("TABLE: ~p~n", [ets:tab2list(background_mgr_table)]),
    exit(whereis(riak_core_bg_manager), kill),
    exit(whereis(riak_core_table_manager), kill).

loop_forever() ->
    timer:sleep(10000),
    loop_forever().
```