[Java] Queue 인터페이스

출처

ChatGPT

---

Queue 인터페이스는 자바 컬렉션 프레임워크에서 FIFO(First-In-First-Out) 원칙에 따라 요소를 처리하는 자료구조를 정의하는 인터페이스이다. 큐가 먼저 추가된 요소가 먼저 제거되는 구조를 따르며, 주로 작업 관리나 메시지 처리와 같은 대기열을 처리할 때 사용된다.

 

Queue 인터페이스는 컬렉션(Collection) 인터페이스를 상속하며, 큐 자료구조의 특화된 메소드들을 정의한다.

 

1. Queue 인터페이스의 주요 특징

FIFO 순서

Queue 는 FIFO(First-In-First-Out) 방식으로 동작한다. 즉, 큐에 먼저 삽입된 요소가 먼저 처리되고 제거된다.

null 허용 안 함

대부분의 큐 구현체는 null 값을 허용하지 않는다. 이는 null이 큐의 끝을 나타내거나 특별한 의미를 가질 수 있기 때문에 예외를 발생시킨다.

동기화 지원

Queue 인터페이스는 멀티스레드 환경에서 동시 접근을 안전하게 처리할 수 있는 동기화 큐 구현에(ConcurrentLinkedQueue, BlockingQueue 등)를 제공한다.

2. Queue 인터페이스의 주요 메소드

Queue 인터페이스는 요소를 삽입, 제거, 조회하는 메소드들을 제공하며, 각 작업에 대해 두 가지 변형을 제공한다.

• 예외를 발생시키는 메소드
• null 또는 false를 반환하는 메소드

1. 삽입 관련 메소드

boolean add(E e)

큐의 맨 뒤에 요소를 삽입한다. 큐의 크기 제한을 초과할 경우 예외를 던진다.

boolean offer(E e)

큐의 맨 뒤에 요소를 삽입한다. 큐가 가득 찬 경우 false를 반환하며, 예외를 발생시키지 않는다.

2. 제거 관련 메소드

E remove()

큐의 첫 번째 요소를 제거하고 반환한다. 큐가 비어 있으면 예외를 던진다.

E poll()

큐의 첫 번째 요소를 제거하고 반환한다. 큐가 비어 있으면 null을 반환한다.

3. 조회 관련 메소드

E element()

큐의 첫 번째 요소를 반환하되, 제거하지 않는다. 큐가 비어 있으면 예외를 던진다. 

E peek()

큐의 첫 번째 요소를 반환하되, 제거하지 않는다. 큐가 비어 있으면 null을 반환한다.

 

3. Queue 인터페이스 메소드 동작 비교

메소드	성공 시 동작	실패 시 동작
add(e)	요소를 큐에 삽입	예외(IllegalStateException) 발생
offer(e)	요소를 큐에 삽입	false 반환
remove()	첫 번째 요소 제거 및 반환	예외(NoSuchElementException) 발생
poll()	첫 번째 요소 제거 및 반환	null 반환
element()	첫 번째 요소 조회	예외(NoSuchElementException) 발생
peek()	첫 번째 요소 조회	null 반환

 

4. Queue 인터페이스의 구현 클래스

Queue 인터페이스를 구현한 주요 클래스들은 각기 다른 특성과 용도를 가지며, 다양한 상황에서 사용할 수 있다.

LinkedList

인터페이스를 구현한 일반적인 연결 리스트 기반 큐로, null 값을 허용한다. 크기에 제한이 없으며, 큐 외에도 리스트로 사용할 수 있다.

PriorityQueue

우선순위 큐로, 삽입된 요소들이 우선순위에 따라 정렬되며, FIFO 규칙 대신 유선순위 규칙을 따른다. 기본적으로 최소 힙을 사용해 우선순위를 관리한다.

ArrayDeque

배열 기반의 큐로, 양쪽에서 삽입과 삭제가 가능한 Deque(Double-Ended Queue)를 구현한다. 스택과 큐의 동작을 모두 지원한다.

ConcurrentLinkedQueue

비동기전(스레드 안전)으로 동작하는 연결 리스트 기반 큐롤, 멀티스레드 환경에서 사용된다.

BlockingQueue

블로킹 큐로, 생산자-소비자 패턴에서 주로 사용되며, 큐가 비어 있으면 요소가 추가될 때까지 기다리고, 큐가 가득 차면 공간이 생길 때까지 기다리는 동작을 한다. 주요 구현체로는 ArrayBlockingQueue, LinkedBlockingQueue, PriorityBlockingQueue 등이 있다.

 

5. Queue 예시

1. LinkedList를 이용한 기본 큐 구현

import java.util.LinkedList;
import java.util.Queue;

public class QueueExample {
    public static void main(String[] args) {
        Queue<String> queue = new LinkedList<>();
        
        // 큐에 요소 삽입
        queue.offer("apple");
        queue.offer("banana");
        queue.offer("cherry");

        // 큐의 첫 번째 요소를 반환하고 제거
        System.out.println("Poll: " + queue.poll());  // 출력: apple

        // 큐의 첫 번째 요소를 조회 (제거하지 않음)
        System.out.println("Peek: " + queue.peek());  // 출력: banana

        // 큐에서 요소를 제거
        System.out.println("Remove: " + queue.remove());  // 출력: banana

        // 남은 요소들 출력
        System.out.println("Remaining Queue: " + queue);  // 출력: [cherry]
    }
}

 

2. PriorityQueue를 이용한 우선순위 큐

import java.util.PriorityQueue;
import java.util.Queue;

public class PriorityQueueExample {
    public static void main(String[] args) {
        Queue<Integer> priorityQueue = new PriorityQueue<>();
        
        // 우선순위 큐에 요소 삽입 (기본적으로 오름차순 정렬)
        priorityQueue.offer(40);
        priorityQueue.offer(10);
        priorityQueue.offer(30);
        priorityQueue.offer(20);

        // 우선순위가 가장 높은 요소를 반환하고 제거
        System.out.println("Poll: " + priorityQueue.poll());  // 출력: 10

        // 큐의 첫 번째 요소를 조회 (제거하지 않음)
        System.out.println("Peek: " + priorityQueue.peek());  // 출력: 20

        // 남은 요소들 출력
        System.out.println("Remaining Queue: " + priorityQueue);  // 출력: [20, 40, 30]
    }
}

 

3. ArrayDeque를 이용한 큐와 스택 동작

import java.util.ArrayDeque;
import java.util.Deque;

public class ArrayDequeExample {
    public static void main(String[] args) {
        Deque<String> deque = new ArrayDeque<>();
        
        // 큐처럼 동작 (FIFO)
        deque.offer("apple");
        deque.offer("banana");
        deque.offer("cherry");

        System.out.println("Queue Poll: " + deque.poll());  // 출력: apple
        System.out.println("Queue Remaining: " + deque);    // 출력: [banana, cherry]

        // 스택처럼 동작 (LIFO)
        deque.push("date");
        System.out.println("Stack Pop: " + deque.pop());    // 출력: date
        System.out.println("Stack Remaining: " + deque);    // 출력: [banana, cherry]
    }
}

 

6. BlockingQueue 예시 (생산자-소비자 패턴)

BlockingQueue는 생산자-소비자(Producer-Consumer) 패턴에서 주로 사용된다. 큐가 비어 있으면 소비자는 기다리고, 큐가 가득 차면 생산자는 기다리는 동작을 수행한다.

• 관련 글 -> [디자인 패턴][Java] 생산자-소비자 패턴 Producer-Consumer Pattern

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class BlockingQueueExample {
    public static void main(String[] args) throws InterruptedException {
        BlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<>(2);

        // 생산자 스레드
        new Thread(() -> {
            try {
                blockingQueue.put(1);
                System.out.println("Produced: 1");
                blockingQueue.put(2);
                System.out.println("Produced: 2");
                blockingQueue.put(3);  // 이 시점에서 블로킹됨 (큐가 가득 찼기 때문)
                System.out.println("Produced: 3");
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();

        // 소비자 스레드
        new Thread(() -> {
            try {
                Thread.sleep(2000);  // 잠시 대기 후 소비 시작
                System.out.println("Consumed: " + blockingQueue.take());
                System.out.println("Consumed: " + blockingQueue.take());
                System.out.println("Consumed: " + blockingQueue.take());
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }).start();
    }
}

 

이 예시에서는 생산자가 큐에 요소를 삽입하고, 큐가 가득 차면 다음 요소를 삽입하기 위해 다기한다. 소비자는 일정 시간이 지난 후 큐에서 요소를 꺼내고, 큐가 비어 있으면 다음 요소가 올 때가지 대기한다.

 

7. Queue 인터페이스의 용도

작업 대기열

여러 작업을 차례대로 처리해야 할 대 큐를 사용해 작업을 저장하고, 처리 완료 후 큐에서 제거하는 방식으로 활용될 수 있다.

메시지 처리 시스템

메시지 큐 시스템에서 메시지를 차례대로 처리하기 위한 자료구조로 사용된다.

멀티스레드 환경

BlockingQueue는 멀티스레드 환경에서 안전하게 데이터를 교환할 수 있는 큐를 제공해, 생산자-소비자 패턴에 적합하다.

 

결론

Queue 인터페이스는 자바에서 FIFO 방식의 큐를 구현하는 데 사용되며, 다양한 구현체가 있어 각기 다른 특성에 맞게 사용할 수 있다. 우선순위 큐, 동기화 큐, 블로킹 큐 등 다양한 상황에 맞는 구현체들이 제공되어, 멀티스레드 환경에서도 안전하고 효율적으로 데이터를 처리할 수 있다.