redis list 사용

참고: http://redis.cn/commands.html#list
BLPOP  key [key...] timeout 을 삭제 하고 이 목록 의 첫 번 째 요 소 를 얻 거나 차단 합 니 다. 사용 가능 할 때 까지 BRPOP  key [key...] timeout 을 삭제 하고 이 목록 의 마지막 요 소 를 가 져 오 거나 차단 할 때 까지 BRPOPLPUSH  source destination timeout 에서 목록 의 값 을 꺼 내 다른 목록 으로 밀어 서 되 돌려 줍 니 다.사용 가능 할 때 까지 차단 LINDEX  key index 는 색인 목록 을 통 해 요 소 를 가 져 옵 니 다.
LINSERT  key BEFORE | AFTER pivot value 는 목록 의 다른 요소 앞 이나 그 다음 에 요 소 를 삽입 합 니 다 LLEN  key 획득 대기 열 (List) 의 길이 LPOP  key 는 대열 의 왼쪽 에서 하나의 요소 를 나 옵 니 다.
LPUSH  key value [value...] 대기 열 왼쪽 에서 하나 이상 의 요소 LPUSHX  key value 가 대기 열 이 존재 할 때 팀 에서 왼쪽 까지 하나의 요소 LRANGE  key start stop 목록 에서 지정 한 반환 요 소 를 가 져 옵 니 다 LREM  key count value 목록 에서 요소 삭제 LSET  key index value 설정 대기 열 에 있 는 요소 의 값 LTRIM  key start stop 지정 한 범위 내 목록 편집 RPOP  key 대기 열 오른쪽 에서 하나의 요소 RPOPLPUSH  source destination 목록 의 마지막 요 소 를 삭제 하고 다른 목록 에 추가 합 니 다 RPUSH  key value [value...] 대기 열 오른쪽 에서 하나의 요소 RPUSHX  key value 종 대  
lpush：
모든 지정 한 값 을 저장 소 에 삽입 합 니 다.  key  목록 의 머리.하면, 만약, 만약...  key  존재 하지 않 습 니 다. push 작업 을 하기 전에 빈 목록 을 만 듭 니 다.하면, 만약, 만약...  key 대응 하 는 값 이 list 가 아니라면 오 류 를 되 돌려 줍 니 다.
하나의 명령 을 사용 하여 여러 요소 push 를 목록 에 넣 을 수 있 습 니 다. 명령 끝 에 지정 한 인 자 를 여러 개 추가 하면 됩 니 다.요 소 는 맨 왼쪽 에서 맨 오른쪽 까지 하나씩 list 의 머리 에 삽입 되 어 있 습 니 다.그래서 이 명령 의 예 에 대해  LPUSH mylist a b c, 돌아 오 는 목록 은?  c  첫 번 째 요 소 를 위해,  b  두 번 째 원 소 를 위해,  a  세 번 째 원소 입 니 다.
반환 값
정형: push 작업 후의 list 길이 입 니 다.
역사.

>= 2.4: 여러 개 받 기  value  매개 변수.2.4 이상 버 전의 Redis 는 명령 마다 push 값 만 사용 할 수 있 습 니 다.

예시
redis> 
LPUSH mylist "world"

(integer) 1

redis> 
LPUSH mylist "hello"

(integer) 2

redis> 
LRANGE mylist 0 -1

1) "hello"
2) "world" (  list       ）

redis> 
 
lpushx:
... 밖 에 없다  key  이미 존재 하고 list 가 저장 되 어 있 을 때, 여기에  key  아래 list 의 머리 삽입  value 。 ... 과  LPUSH  반대로  key  존재 하지 않 을 때 는 아무런 조작 도 하지 않 습 니 다.
 
반환 값
정형: push 작업 후의 list 길이 입 니 다.
 
LRANGE key start stop
메모리  key  의 목록 에서 범위 내의 요 소 를 지정 합 니 다.  start  화해시키다  end  편 이 량 은 모두 0 의 아래 표 시 를 바탕 으로 한다. 즉, list 의 첫 번 째 요 소 는 0 (list 의 표 두) 이 고, 두 번 째 요 소 는 1 로 유추 된다.
오프셋 도 마이너스 일 수 있 으 며 오프셋 은 list 꼬리 부터 계산 한 다 는 뜻 이다.예컨대  -1  목록 의 마지막 요 소 를 표시 합 니 다. -2 꼴찌 에서 두 번 째 로 유추 하 다.
서로 다른 프로 그래 밍 언어 에서 범위 함수 의 일치 성에 대하 여
주의해 야 할 것 은, 만약 당신 이 list 를 가지 고 있다 면, 안의 요소 가 0 에서 100 까지 라면,  LRANGE list 0 10  이 명령 은 11 개의 요 소 를 되 돌려 줍 니 다. 즉, 맨 오른쪽 에 있 는 요소 도 포 함 됩 니 다.당신 이 사용 하 는 프로 그래 밍 언어 에서 이 점 은 범위 와 관련 된 함수 들 이 모두 일치 하지 않 을 수도 있 습 니 다.(루비 같 아 요.  Range.new ， Array#slice  파 이 썬  range()  함수
범위 초과 하 표
아래 표 시 는 list 범 위 를 초과 할 때 error 가 발생 하지 않 습 니 다.start list 의 끝 에 표 시 된 것 보다 크 면 빈 목록 으로 돌아 갑 니 다.만약 stop 이 list 의 실제 꼬리 보다 클 때 Redis 는 마지막 요소 의 아래 표 시 를 할 것 이다.
반환 값
복수 응답: 지정 한 범위 의 목록 요소 입 니 다.
 
lpop:
제거 및 복귀  key  대응 하 는 list 의 첫 번 째 요소 입 니 다.
반환 값
대량 복구: 첫 번 째 원소 의 값 을 되 돌려 주거 나,  key  존재 하지 않 을 때 되 돌아 가기  nil 。
예시
redis> 
RPUSH mylist "one"

(integer) 1


LLEn key

버 전 추가 1.0.0。
시간 복잡 도: O(1)。
메모리  key  안의 list 길이.하면, 만약, 만약...  key  존재 하지 않 습 니 다. 그러면 빈 list 로 간주 되 고 길 이 를 되 돌려 줍 니 다.  0 。 저장 소  key  값 이 list 가 아니면 error 로 돌아 갑 니 다.
LREM/LSET/LINDEX/LTRIM:
LREM key count value

     1.0.0。
     ： O(N)，  N  list   。
    key         count        value    。    count                 ：
count > 0:          value    。
count < 0:          value    。
count = 0:        value    。
  ， LREM list -2 "hello"      list               "hello"。
      ，  list     key      list  ，    key       ，        0。
   
    :         。
  
redis> RPUSH mylist "hello"
(integer) 1
redis> RPUSH mylist "hello"
(integer) 2
redis> RPUSH mylist "foo"
(integer) 3
redis> RPUSH mylist "hello"
(integer) 4
redis> LREM mylist -2 "hello"
(integer) 2
redis> LRANGE mylist 0 -1
1) "hello"
2) "foo"
redis> 

 
lindex key index:

     1.0.0。
     ： O(N)，  N                    。       list                  O(1)。
            index     key   。     0     ，   0         ， 1        ，     。                     。      ，-1         ，-2          ，      。
  key              ，     error。
   
    ：       ，    index           nil。

redis> LPUSH mylist "World"

(integer) 1

redis> LPUSH mylist "Hello"

(integer) 2

redis> LINDEX mylist 0

"Hello"

redis> LINDEX mylist -1

"World"

redis> LINDEX mylist 3

(nil)

redis>
 
lset key index value:

     1.0.0。
     ： O(N)，  N  list   。  list                 O(1)。
   index    list      value。      index      ，   LINDEX。
 index          error。
   
    
  
redis> RPUSH mylist "one"
(integer) 1
redis> RPUSH mylist "two"
(integer) 2
redis> RPUSH mylist "three"
(integer) 3
redis> LSET mylist 0 "four"
OK
redis> LSET mylist -2 "five"
OK
redis> LRANGE mylist 0 -1
1) "four"
2) "five"
3) "three"
redis> 

LTRIM key start stop

     1.0.0。
     ： O(N)    N               。
  (trim)       list，   list               。start   stop    0     ，     0           （  ），1       ，    。
  ： LTRIM foobar 0 2        foobar        ，        3   。
start   end                 ，   -1             ， -2        ，  。
              ：   start       ，   start > end，          （   key     ）。    end       ，Redis               。
LTRIM           LPUSH / RPUSH     。   ：
LPUSH mylist someelement
LTRIM mylist 0 99               push     ，             100   。       ，     Redis      。         ，          LTRIM    ，        O(1) ，        ，            。
   
    
  
redis> RPUSH mylist "one"
(integer) 1
redis> RPUSH mylist "two"
(integer) 2
redis> RPUSH mylist "three"
(integer) 3
redis> LTRIM mylist 1 -1
OK
redis> LRANGE mylist 0 -1
1) "two"
2) "three"
redis> 

LINSERT key BEFORE|AFTER pivot value

     2.2.0。
     ： O(N)，  N     pivot            。      list   （  ）         O(1)，  list   （  ）     O(N)。
  value      key          pivot       。
  key     ，  list      list，         。
  key   ，        list   ，   error。
   
    :         list  ，    pivot           -1。
  
redis> RPUSH mylist "Hello"
(integer) 1
redis> RPUSH mylist "World"
(integer) 2
redis> LINSERT mylist BEFORE "World" "There"
(integer) 3
redis> LRANGE mylist 0 -1
1) "Hello"
2) "There"
3) "World"
redis> 

RPUSH/RPUSHX/RPOP/RPOPLPUSH:

    #    ，        。
    redis 127.0.0.1:6379> del mykey
    (integer) 1
    #              values，             。
    redis 127.0.0.1:6379> rpush mykey a b c d
    (integer) 4
    #  lrange     rpush           。
    redis 127.0.0.1:6379> lrange mykey 0 -1
    1) "a"
    2) "b"
    3) "c"
    4) "d"
    #          4   ，rpushx       ，    e        。
    redis 127.0.0.1:6379> rpushx mykey e
    (integer) 5
    #  lindex         rpushx        ，      4          。
    redis 127.0.0.1:6379> lindex mykey 4
    "e"
    #  mykey2     ，           ，     0。
    redis 127.0.0.1:6379> rpushx mykey2 e
    (integer) 0
    #   rpoplpush   ，    mykey         ，         。
    redis 127.0.0.1:6379> lrange mykey 0 -1
    1) "a"
    2) "b"
    3) "c"
    4) "d"
    5) "e"
    # mykey     e  ，      mykey2   (           )。
    redis 127.0.0.1:6379> rpoplpush mykey mykey2
    "e"
    #  lrange    mykey           。
    redis 127.0.0.1:6379> lrange mykey 0 -1
    1) "a"
    2) "b"
    3) "c"
    4) "d"
    #  lrange    mykey2         。
    redis 127.0.0.1:6379> lrange mykey2 0 -1
    1) "e"
    # source destination     ， mykey           。
    redis 127.0.0.1:6379> rpoplpush mykey mykey
    "d"
    #      。
    redis 127.0.0.1:6379> lrange mykey 0 -1
    1) "d"
    2) "a"
    3) "b"
    4) "c"

RPOPLPUSH source destination

     1.2.0。
     ： O(1)。
             source           （      ），            destination            （    ）。
  ：   source       a,b,c， destination      x,y,z。    RPOPLPUSH        source       a,b ，  destination       c,x,y,z。
   source    ，      nil  ，          。    source   destination     ，                               ，                      。
   
    :          
  
redis> RPUSH mylist "one"
(integer) 1
redis> RPUSH mylist "two"
(integer) 2
redis> RPUSH mylist "three"
(integer) 3
redis> RPOPLPUSH mylist myotherlist
"three"
redis> LRANGE mylist 0 -1
1) "one"
2) "two"
redis> LRANGE myotherlist 0 -1
1) "three"
redis> 

모드: 안전 한 대기 열
Redis 는 보통 각종 배경 작업 이나 메시지 작업 을 처리 하 는 메시지 서버 로 사용 된다.간단 한 대기 열 모드 는 생산자 가 메 시 지 를 목록 에 넣 고 메 시 지 를 기다 리 는 소비자 가 사용 하 는 것 이다.  RPOP  명령  BRPOP  명령 (클 라 이언 트 가 차단 작업 을 사용 하면 더 좋 습 니 다) 을 통 해 이 메 시 지 를 얻 을 수 있 습 니 다.
그러나 메 시 지 를 잃 어 버 릴 수 있 기 때문에 이 대기 열 은 안전 하지 않다.예 를 들 어 메 시 지 를 받 은 후에 인터넷 문제 가 발생 하거나 소비자 측 이 무 너 지면 이 소식 은 잃 어 버 린 것 이다.
RPOPLPUSH  (또는 차단 버 전의  BRPOPLPUSH 이 문 제 를 피 하 는 방법 을 제공 합 니 다. 소비자 가 메 시 지 를 가 져 오 는 동시에 이 메 시 지 를 처리 중인 목록 에 넣 습 니 다. 메시지 가 처리 되면 이 명령 은 사 용 됩 니 다.  LREM  처리 중인 목록 에 있 는 대응 하 는 메 시 지 를 제거 하 는 명령 입 니 다.
또한 처리 중인 목록 을 감시 하기 위해 클 라 이언 트 를 추가 할 수 있 습 니 다. 이 목록 에 오 랜 시간 이 존재 하 는 메시지 가 있 으 면 이 클 라 이언 트 는 시간 초과 메 시 지 를 대기 열 에 다시 추가 합 니 다.
모드: 순환 목록
RPOPLPUSH  명령 의  source  화해시키다  destination  같은 경우 클 라 이언 트 가 n 개의 요 소 를 가 진 목록 에 접근 할 때 O(N) 시간 에 목록 요 소 를 하나씩 가 져 옵 니 다.  LRANGE  그러면 전체 목록 을 서버 에서 클 라 이언 트 로 전송 해 야 합 니 다.
위의 모드 는 다음 과 같은 두 가지 상황 에서 도 잘 작 동 합 니 다. * 여러 개의 클 라 이언 트 가 같은 목록 을 동시에 회전 (rotating) 합 니 다. 목록 에 있 는 모든 요소 가 접근 할 때 까지 서로 다른 요 소 를 얻 고 처음부터 이 작업 을 시작 합 니 다. * 다른 클 라 이언 트 가 목록 끝 에 새로운 요 소 를 추가 합 니 다.
이 모델 은 우리 로 하여 금 이러한 시스템 을 쉽게 실현 할 수 있 게 한다. N 개의 클 라 이언 트 가 있 기 때문에 일련의 요 소 를 계속 처리 해 야 하고 처리 하 는 과정 이 가능 한 한 빨리 이 루어 져 야 한다. 전형 적 인 예 는 서버 의 모니터링 프로그램 이다. 그들 은 가능 한 한 짧 은 시간 안에 한 개의 사 이 트 를 병행 적 으로 검사 하여 그들의 접근 성 을 확보 해 야 한다.
주의해 야 할 것 은 이 모드 를 사용 하 는 클 라 이언 트 는 확장 (scalable) 하기 쉽 고 안전 합 니 다. 클 라 이언 트 가 받 은 메 시 지 를 잃 어 버 렸 더 라 도 이 메 시 지 는 대기 열 에 존재 합 니 다. 다음 에 교체 할 때 다른 클 라 이언 트 가 처리 합 니 다.
링크 구조의 작은 기술:      링크 구조의 Value 에 대해 Redis 는 공식 문서 에서 RPOPLPUSH 명령 과 같은 실 용적 인 기 교 를 제시 했다. 다음은 구체 적 인 설명 을 한다.      Redis 링크 는 다 중 프로그램 간 메시지 교환 을 위해 메시지 큐 서비스 에 자주 사 용 됩 니 다. 한 프로그램 이 LPUSH 작업 을 수행 하고 있다 고 가정 하고 링크 에 새로운 요 소 를 추가 합 니 다. 우 리 는 보통 이러한 프로그램 을 '생산자 (Producer)' 라 고 부 릅 니 다. 다른 프로그램 은 RPOP 작업 을 수행 하고 있 습 니 다. 링크 에서 요 소 를 꺼 냅 니 다. 우 리 는 이러한 프로그램 을 '생산자 (Producer)' 라 고 부 릅 니 다."소비자 (소비자)"이 경우, 소비자 프로그램 은 메시지 요 소 를 제거 한 후 즉시 붕 괴 됩 니 다. 이 메시지 가 제거 되 었 고 정상적으로 처리 되 지 않 았 기 때문에 이 메시지 가 분실 되 었 다 고 볼 수 있 습 니 다. 이 로 인해 업무 데이터 가 손실 되 거나 업무 상태 가 일치 하지 않 는 등 현상 이 발생 할 수 있 습 니 다. 그러나 RPOPLPUSH 명령 을 사용 하여 소비자 프로그램 은 메 인 메시지 대기 열 에서 가 져 옵 니 다.메 시 지 를 보 낸 후 백업 대기 열 에 삽입 합 니 다. 소비자 프로그램 이 정상 적 인 처리 논 리 를 마 친 후에 이 메 시 지 를 백업 대기 열 에서 삭제 합 니 다. 또한 백업 대기 열 에 있 는 메시지 가 만 료 된 것 을 발견 하면 다른 소비자 프로그램 이 계속 처리 할 수 있 도록 데 몬 을 제공 할 수 있 습 니 다.
참고: http://www.cnblogs.com/stephen-liu74/archive/2012/03/16/2351859.html