🔴 Redis - List 타입

📋 List 타입 소개

Redis의 List 타입은 하나의 Key에 여러 개의 문자열(String)을 순서대로 저장할 수 있는 자료구조입니다.

내부적으로는 이중 연결 리스트(Doubly Linked List) 형태로 구현되어 있습니다.

이러한 구조적 특징 때문에 다음과 같은 명확한 장단점을 가집니다.

장점: 리스트의 양 끝(Head/Tail)에 데이터를 추가하거나 뺄 때는 데이터 양과 무관하게 항상 일정한 속도인 $O(1)$의 성능을 보장합니다.
단점: 리스트의 중간 특정 인덱스(Index)에 접근하여 값을 찾을 때는 리스트를 순회해야 하므로 $O(N)$의 시간이 소요됩니다.

💡 포인트 List 타입은 주로 먼저 들어온 데이터를 먼저 처리하는
메시지 큐(Message Queue)
최근 검색어 목록, 혹은 SNS의 최신 피드(Timeline)를 캐싱하는 용도로 아주 활발하게 사용됩니다.

🔗 참고 자료

Redis 공식 문서 - Redis Lists

🛠️ 주요 명령어 요약

방향(Left/Right)을 명확히 지정하여 삽입과 삭제를 수행하는 것이 특징입니다.

명령어	설명	대표적인 활용 예시
`LPUSH` / `RPUSH`	리스트의 왼쪽(Head) / 오른쪽(Tail)에 값을 추가합니다.	큐(Queue)나 스택(Stack)에 데이터 적재
`LPOP` / `RPOP`	리스트의 왼쪽(Head) / 오른쪽(Tail)에서 값을 꺼내고 삭제합니다.	적재된 작업 처리 (Dequeue)
`LRANGE`	시작과 끝 인덱스를 지정하여 리스트의 특정 범위를 조회합니다.	최근 게시글 목록, 채팅 내역 페이징 조회
`LLEN`	리스트의 전체 길이를 반환합니다.	대기 중인 작업 개수 확인
`LINDEX`	리스트의 특정 인덱스에 있는 값을 조회합니다.	특정 순번의 데이터 단건 확인
`LINSERT`	특정 값의 앞(BEFORE)이나 뒤(AFTER)에 새로운 값을 삽입합니다.	순서가 중요한 특정 항목 사이에 데이터 추가
`LREM`	리스트에서 지정한 값을 원하는 개수만큼 삭제합니다.	중복 저장된 특정 불량 데이터 정리
`BLPOP` / `BRPOP`	리스트에서 값을 꺼낼 때, 값이 없다면 생길 때까지 대기(Block) 합니다.	실시간 이벤트 처리, Worker 노드의 작업 대기

🚀 기능 소개 및 활용 예제

Java 환경(Lettuce 라이브러리)에서 Redis List를 어떻게 다루는지 용도별로 나누어 코드로 살펴보겠습니다.

이전 글과 마찬가지로, 다른 환경 중 node.js 와 spring 은 다음 github 를 통해 확인이 가능합니다.
Java
Node.js
Spring

Queue (큐) 처럼 사용하기 (FIFO)

큐는 먼저 들어온 데이터가 먼저 나가는 FIFO(First In, First Out) 구조입니다.

Redis에서는 오른쪽에 데이터를 넣고(RPUSH), 왼쪽에서 꺼내는(LPOP) 방식으로 간단히 구현할 수 있습니다.

// =========================================================
// Queue 처럼 사용하기 (FIFO: First In, First Out)
// =========================================================

// 1. rpush: 리스트의 오른쪽(tail) 에 값을 추가
System.out.println("=========rpush=========");
Long rpushCount = command.rpush("queue", "task1");
System.out.println("rpush 후 리스트 길이 : " + rpushCount);
rpushCount = command.rpush("queue", "task2", "task3");
System.out.println("rpush 2개 후 리스트 길이 : " + rpushCount);
// 현재 상태: [task1, task2, task3]

// 2. lrange: 리스트의 특정 범위를 조회 (0부터 -1은 전체 조회)
System.out.println("=========lrange=========");
List<String> queueList = command.lrange("queue", 0, -1);
System.out.println("전체 조회 : " + queueList);
List<String> partialList = command.lrange("queue", 0, 1);
System.out.println("0~1 범위 조회 : " + partialList);

// 3. lpop: 리스트의 왼쪽(head) 에서 값을 꺼냄 (Queue 의 dequeue)
System.out.println("=========lpop (Queue dequeue)=========");
String firstTask = command.lpop("queue");
System.out.println("꺼낸 작업 : " + firstTask);          // task1
System.out.println("남은 큐 : " + command.lrange("queue", 0, -1));
// 현재 상태: [task2, task3]

=========rpush=========
rpush 후 리스트 길이 : 1
rpush 2개 후 리스트 길이 : 3
=========lrange=========
전체 조회 : [task1, task2, task3]
0~1 범위 조회 : [task1, task2]
=========lpop (Queue dequeue)=========
꺼낸 작업 : task1
남은 큐 : [task2, task3]

2. Stack (스택) 처럼 사용하기 (LIFO)

스택은 나중에 들어온 데이터가 먼저 나가는 LIFO(Last In, First Out) 구조입니다.

왼쪽으로 넣고(LPUSH), 왼쪽으로 빼는(LPOP) 방식으로 구현합니다.

// =========================================================
// Stack 처럼 사용하기 (LIFO: Last In, First Out)
// =========================================================

// 4. lpush: 리스트의 왼쪽(head) 에 값을 추가
System.out.println("=========lpush=========");
command.del("stack");
Long lpushCount = command.lpush("stack", "page1");
System.out.println("lpush 후 리스트 길이 : " + lpushCount);

// 여러 값을 추가할 때, 마지막 인자가 가장 왼쪽에 위치함 (결과: page3, page2, page1)
lpushCount = command.lpush("stack", "page2", "page3");
System.out.println("lpush 2개 후 리스트 길이 : " + lpushCount);
System.out.println("스택 상태 : " + command.lrange("stack", 0, -1));

// 5. lpop: 가장 최근에 넣은 왼쪽(head) 값을 꺼냄 (Stack pop)
System.out.println("=========lpop (Stack pop)=========");
String topPage = command.lpop("stack");
System.out.println("꺼낸 페이지 (가장 최근) : " + topPage);   // page3
System.out.println("남은 스택 : " + command.lrange("stack", 0, -1));

// 6. rpop: 반대로 오른쪽(tail) 에서 값을 꺼낼 수도 있음
System.out.println("=========rpop=========");
command.rpush("mylist", "a", "b", "c");
String lastItem = command.rpop("mylist");
System.out.println("오른쪽에서 꺼낸 값 : " + lastItem);       // c
System.out.println("남은 리스트 : " + command.lrange("mylist", 0, -1));

=========lpush=========
lpush 후 리스트 길이 : 1
lpush 2개 후 리스트 길이 : 3
스택 상태 : [page3, page2, page1]
=========lpop (Stack pop)=========
꺼낸 페이지 (가장 최근) : page3
남은 스택 : [page2, page1]
=========rpop=========
오른쪽에서 꺼낸 값 : c
남은 리스트 : [a, b]

3. 리스트 정보 조회 및 수정

데이터를 넣고 빼는 것 외에도, 길이를 재거나 특정 위치의 값을 조회하고 수정하는 기능들도 제공합니다.

// 7. llen: 리스트의 길이를 반환 (키가 없으면 0)
System.out.println("=========llen=========");
Long listLen = command.llen("mylist");
System.out.println("mylist 길이 : " + listLen);
Long notExistLen = command.llen("notExistKey");
System.out.println("없는 키의 길이 : " + notExistLen);

// 8. lindex: 특정 인덱스의 값을 조회 (-1은 마지막 요소)
System.out.println("=========lindex=========");
String firstItem = command.lindex("mylist", 0);
System.out.println("0번 인덱스 : " + firstItem);            // a
String lastIndex = command.lindex("mylist", -1);
System.out.println("-1번 인덱스(마지막) : " + lastIndex);   // b
String outOfRange = command.lindex("mylist", 99);
System.out.println("범위 초과 인덱스 : " + outOfRange);     // null

// 9. linsert: 특정 값의 앞(BEFORE) 또는 뒤(AFTER) 에 새 값을 삽입
System.out.println("=========linsert=========");
Long afterInsert = command.linsert("mylist", true, "b", "b_before");
System.out.println("b 앞에 b_before 삽입 후 길이 : " + afterInsert);
// 결과: [a, b_before, b]

// 10. lrem: 리스트에서 특정 값을 지정한 개수(count)만큼 제거
// count > 0: 앞에서부터, count < 0: 뒤에서부터, count = 0: 모두 제거
System.out.println("=========lrem=========");
command.del("remlist");
command.rpush("remlist", "x", "y", "x", "z", "x"); // [x, y, x, z, x]
Long removed = command.lrem("remlist", 2, "x");
System.out.println("'x' 2개 제거 완료, 제거된 개수 : " + removed);
// 결과: [y, z, x] (앞에서 2개 제거됨)

=========llen=========
mylist 길이 : 2
없는 키의 길이 : 0
=========lindex=========
0번 인덱스 : a
-1번 인덱스(마지막) : b
범위 초과 인덱스 : null
=========linsert=========
b 앞에 b_before 삽입 후 길이 : 3
삽입 후 리스트 : [a, b_before, b]
=========lrem=========
'x' 2개 제거 완료, 제거된 개수 : 2
제거 후 리스트 : [y, z, x]

4. Blocking POP (실시간 작업 큐 구현) ⭐

실무에서 아주 중요한 Blocking 기능입니다.

리스트가 비어있을 때 값이 들어올 때까지 지정한 시간만큼 대기(Block)하다가, 값이 들어오면 즉시 꺼내는 명령어입니다.

⚠️ 주의사항: Blocking 명령어는 해당 커넥션을 대기 상태로 점유합니다.
따라서 웹 애플리케이션의 메인 스레드나 공용 커넥션 풀에서 사용하면 장애가 발생할 수 있으므로, 반드시 별도의 커넥션/스레드를 분리하여 사용해야 합니다.
Spring Data Redis 에서는 기본 ThreadPool 을 제공합니다.

// 11. blpop - 데이터가 이미 있을 때 (즉시 반환)
System.out.println("=========blpop (데이터 있을 때)=========");
command.del("blqueue");
command.rpush("blqueue", "job1", "job2");
KeyValue<String, String> blpopResult = command.blpop(3, "blqueue"); // 3초 대기
System.out.println("blpop 결과 - 키 : " + blpopResult.getKey() + ", 값 : " + blpopResult.getValue());

// 12. blpop - 빈 리스트에서 대기 후 반환 (이벤트 드리븐)
System.out.println("=========blpop (빈 리스트 대기)=========");
command.del("blqueue");

// [생산자] 별도 스레드에서 1초 후 데이터를 삽입 (별도 Connection 사용 필수)
Thread producer = new Thread(() -> {
   try (StatefulRedisConnection<String, String> producerConn = redisConnect.getConnection()) {
      RedisCommands<String, String> producerCmd = producerConn.sync();
      Thread.sleep(1000);
      producerCmd.rpush("blqueue", "delayed_job");
      System.out.println("[생산자] delayed_job 삽입 완료");
   } catch (InterruptedException e) {
      Thread.currentThread().interrupt();
   }
});
producer.start();

// [소비자] 최대 5초 대기. 생산자가 1초 뒤에 넣으면 즉시 깨어나서 값을 가져옴.
System.out.println("[소비자] blqueue 에서 데이터 대기 중... (최대 5초)");
KeyValue<String, String> delayedResult = command.blpop(5, "blqueue");
if (delayedResult != null) {
   System.out.println("[소비자] blpop 수신 - 키 : " + delayedResult.getKey() + ", 값 : " + delayedResult.getValue());
}

// 13. blpop - timeout 초과 시 null 반환
System.out.println("=========blpop (timeout 초과)=========");
command.del("emptyQueue");
KeyValue<String, String> timeoutResult = command.blpop(2, "emptyQueue");
System.out.println("timeout 발생 여부 : " + (timeoutResult == null ? "null 반환" : "수신"));

// 14. brpop - 오른쪽(tail) 에서 Blocking POP
System.out.println("=========brpop=========");
command.del("brqueue");
command.rpush("brqueue", "item1", "item2");
KeyValue<String, String> brpopResult = command.brpop(3, "brqueue");
// 오른쪽에서 꺼내므로 item2 가 반환됨

=========blpop (데이터 있을 때)=========
blpop 결과 - 키 : blqueue, 값 : job1
=========blpop (빈 리스트 대기)=========
[소비자] blqueue 에서 데이터 대기 중... (최대 5초)
[생산자] delayed_job 삽입 완료
[소비자] blpop 수신 - 키 : blqueue, 값 : delayed_job
=========blpop (timeout 초과)=========
[소비자] emptyQueue 에서 대기 중... (최대 2초)
timeout 발생 → null 반환
=========brpop=========
brpop 결과 - 키 : brqueue, 값 : item3

📝 마무리 및 요약

Redis List 타입은 연결 리스트 기반으로, 양 끝단의 데이터 조작 속도가 O(1)로 매우 빠르다는 점이 핵심입니다.

단순히 데이터를 넣고 빼는 LPUSH, RPOP을 조합하여 Queue나 Stack을 쉽게 구현할 수 있으며, 특히 실시간으로 이벤트를 처리해야 하는 백그라운드 워커(Worker) 시스템에서는 BLPOP과 같은 Blocking 명령어를 통해 CPU 자원 낭비 없는 효율적인 메시지 큐 시스템을 구축할 수 있습니다.

[Redis 완전 정복] Redis List 타입 알아보기