Removes and returns the first element in a list. Blocks until an element is available otherwise. Deletes the list if the last element was popped.
BLPOP
key [key…]
timeout
BLPOP
is a blocking list pop primitive. It is the
blocking version of LPOP
because it blocks the connection
when there are no elements to pop from any of the given lists. An
element is popped from the head of the first list that is non-empty,
with the given keys being checked in the order that they are given.
When BLPOP
is called, if at least one of the specified
keys contains a non-empty list, an element is popped from the head of
the list and returned to the caller together with the key
it was popped from.
Keys are checked in the order that they are given. Let’s say that the
key list1
doesn’t exist and list2
and
list3
hold non-empty lists. Consider the following
command:
BLPOP list1 list2 list3 0
BLPOP
guarantees to return an element from the list
stored at list2
(since it is the first non empty list when
checking list1
, list2
and list3
in that order).
If none of the specified keys exist, BLPOP
blocks the
connection until another client performs an LPUSH
or
RPUSH
operation against one of the keys.
Once new data is present on one of the lists, the client returns with the name of the key unblocking it and the popped value.
When BLPOP
causes a client to block and a non-zero
timeout is specified, the client will unblock returning a
nil
multi-bulk value when the specified timeout has expired
without a push operation against at least one of the specified keys.
The timeout argument is interpreted as a double value specifying the maximum number of seconds to block. A timeout of zero can be used to block indefinitely.
BLPOP key1 key2 key3 key4 0
, assuming that both
key2
and key4
are non-empty, will always
return an element from key2
.BLPOP
it will be served accordingly to the number of clients already blocked
for the same key, that will all be served before it (from the first to
the last that blocked).BLPOP
when multiple elements are pushed inside a
list.There are times when a list can receive multiple elements in the context of the same conceptual command:
LPUSH mylist a b c
.EXEC
of a MULTI
block with
multiple push operations against the same list.What happens is that the command performing multiple pushes is executed, and only after the execution of the command the blocked clients are served. Consider this sequence of commands.
Client A: BLPOP foo 0
Client B: LPUSH foo a b c
If the above condition happens using a Redis OSS 2.6 server or
greater, Client A will be served with the
c
element, because after the LPUSH
command the
list contains c,b,a
, so taking an element from the left
means to return c
.
Note that for the same reason a Lua script or a
MULTI/EXEC
block may push elements into a list and
afterward delete the list. In this case the blocked
clients will not be served at all and will continue to be blocked as
long as no data is present on the list after the execution of a single
command, transaction, or script.
BLPOP
inside
a MULTI
/ EXEC
transactionBLPOP
can be used with pipelining (sending multiple
commands and reading the replies in batch), however this setup makes
sense almost solely when it is the last command of the pipeline.
Using BLPOP
inside a MULTI
/
EXEC
block does not make a lot of sense as it would require
blocking the entire server in order to execute the block atomically,
which in turn does not allow other clients to perform a push operation.
For this reason the behavior of BLPOP
inside
MULTI
/ EXEC
when the list is empty is to
return a nil
multi-bulk reply, which is the same thing that
happens when the timeout is reached.
If you like science fiction, think of time flowing at infinite speed
inside a MULTI
/ EXEC
block…
One of the following:
Nil reply: no element could be popped and the timeout expired
Array reply: the key from which the element was popped and the value of the popped element.
One of the following:
Null reply: no element could be popped and the timeout expired
Array reply: the key from which the element was popped and the value of the popped element.
O(N) where N is the number of provided keys.
@blocking @list @slow @write
127.0.0.1:6379> DEL list1 list2
(integer) 0
127.0.0.1:6379> RPUSH list1 a b c
(integer) 3
127.0.0.1:6379> BLPOP list1 list2 0
1) "list1"
2) "a"
When BLPOP
returns an element to the client, it also
removes the element from the list. This means that the element only
exists in the context of the client: if the client crashes while
processing the returned element, it is lost forever.
This can be a problem with some application where we want a more
reliable messaging system. When this is the case, please check the
BRPOPLPUSH
command, that is a variant of BLPOP
that adds the returned element to a target list before returning it to
the client.
Using blocking list operations it is possible to mount different
blocking primitives. For instance for some application you may need to
block waiting for elements into a Set, so that as far as a new element
is added to the Set, it is possible to retrieve it without resort to
polling. This would require a blocking version of SPOP
that
is not available, but using blocking list operations we can easily
accomplish this task.
The consumer will do:
LOOP forever
WHILE SPOP(key) returns elements
... process elements ...
END
BRPOP helper_key
END
While in the producer side we’ll use simply:
MULTI
SADD key element
LPUSH helper_key x
EXEC
timeout
is interpreted as a double instead of an
integer.BLMOVE, BLMPOP, BRPOP, LINDEX, LINSERT, LLEN, LMOVE, LMPOP, LPOP, LPOS, LPUSH, LPUSHX, LRANGE, LREM, LSET, LTRIM, RPOP, RPUSH, RPUSHX.