[디자인 패턴][Java] 생산자-소비자 패턴 Producer-Consumer Pattern

출처

ChatGPT

---

생산자-소비자(Producer-Consumer) 패턴은 멀티스레드 환경에서 생산자(Producer)와 소비자(Consumer) 스레드 간의 데이터를 안전하게 공유하기 위한 디자인 패턴이다. 이 패턴은 공유 자원을 두고 여러 스레드가 동시에 접근할 때 발생할 수 있는 문제를 해결하기 위해 사용되며, 일반적으로 버퍼(큐)를 사용해 데이터를 주고받는다.

 

1. 생산자-소비자 패턴의 개념

생산자 Producer

데이터를 생성하는 스레드로, 생산된 데이터를 버퍼나 큐에 저장한다.

소비자 Consumer

생산자가 생성한 데이터를 버퍼에서 가져와 처리하는 스레드

 

 

버퍼는 생산자가 데이터를 저장하고, 소비자가 데이터를 가져오는 공유된 자원이다. 버퍼가 가득 찬 경우, 생산자는 데기하고, 버퍼가 비어 있는 경우, 소비자는 대기해야 한다. 생산자와 소비자가 동깃에 버퍼에 접근하는 경우 동기화가 필요하다.

 

2. 생산자-소비자 패턴의 동작 원리

이 패턴은 동기화 매커니즘을 통해 데이터를 안전하게 공유하고, 생산자가 데이터를 더 이상 생성하지 않도록 하고, 소비자가 데이터를 처리할 수 있는 상황을 만들어준다.

• 생산자는 버퍼에 데이터를 추가하고, 버퍼가 가득 차면 더 이상 데이터를 추가할 수 없기 때문에 대기한다.
• 소비자는 버퍼에서 데이터를 가져가며, 버퍼가 비어 있으면 데이터를 가져올 수 없기 때문에 대기한다.
• 이 과정에서 버퍼의 크기를 고려한 동기화가 필요하며, 생산자-소비자 문제는 대개 버퍼를 기준으로 데이터를 안전하게 공유하는 방식으로 해결된다.

 

3. 주요 문제점 및 해결 방법

1. 동시성 문제

여러 스레드가 동시에 버퍼에 접근하는 상황에서, 데이터의 일관성을 유지하기 위해 동기화가 필요하다. 자바에서는 synchronized(), wait(), notify(), notifyAll()과 같은 동기화 매커니즘을 통해 이 문제를 해결한다.

2. 버퍼가 가득 찬 경우 Overflow

버퍼가 가득 차면 생산자는 더 이상 데이터를 추가할 수 없기 때문에 대기한다. 이 상태는 버퍼가 비워질 때까지 지속된다.

3. 버퍼가 비어 있는 경우 Underflow

버퍼가 비어 있으면 소비자는 데이터를 가져올 수 없으므로, 생산자가 새로운 데이터를 추가할 때까지 대기해야 한다.

 

4. 생산자-소비자 패턴의 규현 방법

자바에서 생산자-소비자 패턴을 구현할 때는 일반적으로  BlockinigQueue를 사용하거나, synchronized, wait(), notify() 메소드를 통해 직접 동기화를 제어할 수 있다.

1. BlockingQueue를 사용한 생산자-소비자 패턴

BlockingQueue는 큐가 가득 찼을 때 자동으로 생산자를 대기시키고, 큐가 비었을 때 자동으로 소비자를 대기시키는 동기화 큐이다.

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

public class ProducerConsumerExample {
    public static void main(String[] args) {
        // 크기가 5인 BlockingQueue 생성
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(5);

        // 생산자 스레드
        Thread producer = new Thread(() -> {
            try {
                for (int i = 1; i <= 10; i++) {
                    System.out.println("Produced: " + i);
                    queue.put(i);  // 큐가 가득 차면 대기
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        // 소비자 스레드
        Thread consumer = new Thread(() -> {
            try {
                for (int i = 1; i <= 10; i++) {
                    Integer value = queue.take();  // 큐가 비어 있으면 대기
                    System.out.println("Consumed: " + value);
                }
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        producer.start();
        consumer.start();
    }
}

 

출력 예시

Produced: 1
Produced: 2
Produced: 3
Consumed: 1
Consumed: 2
Produced: 4
Consumed: 3
...

 

• BlockingQueue는 생산자-소비자 패턴에서 동기화를 명시적으로 처리하지 않아도 된다. 큐가 가득 차면 자동으로 생산자가 대기하고, 비어 있으면 소비자가 대기한다.
• put() 메소드는 큐가 가득 차면 대기하고, take() 메소드는 큐가 비어 있으면 대기한다.

2. synchronized, wait(), notify()를 이용한 생산자-소비자 패턴

다음은 synchronized 키워드와 wait(), notify() 메소드를 사용한 예시이다. wait()는 스레드를 대기 상태로 만들고, notify()는 대기 중인 스레드를 깨우는 동작을 수행한다.

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

class ProducerConsumer {
    private final Queue<Integer> queue = new LinkedList<>();
    private final int MAX_SIZE = 5;

    // 생산자 메서드
    public void produce() throws InterruptedException {
        int value = 0;
        while (true) {
            synchronized (this) {
                while (queue.size() == MAX_SIZE) {
                    wait();  // 큐가 가득 차면 대기
                }
                System.out.println("Produced: " + value);
                queue.add(value++);
                notify();  // 소비자에게 신호를 보내 대기 상태에서 깨움
            }
        }
    }

    // 소비자 메서드
    public void consume() throws InterruptedException {
        while (true) {
            synchronized (this) {
                while (queue.isEmpty()) {
                    wait();  // 큐가 비어 있으면 대기
                }
                int value = queue.poll();
                System.out.println("Consumed: " + value);
                notify();  // 생산자에게 신호를 보내 대기 상태에서 깨움
            }
        }
    }
}

public class ProducerConsumerExample {
    public static void main(String[] args) {
        ProducerConsumer pc = new ProducerConsumer();

        // 생산자 스레드
        Thread producer = new Thread(() -> {
            try {
                pc.produce();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        // 소비자 스레드
        Thread consumer = new Thread(() -> {
            try {
                pc.consume();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        });

        producer.start();
        consumer.start();
    }
}

 

출력 예시

Produced: 0
Produced: 1
Produced: 2
Produced: 3
Produced: 4
Consumed: 0
Consumed: 1
Produced: 5
Consumed: 2
Produced: 6
...

 

• wait() : 생산자가 큐가 가득 찼을 때 또는 소비자가 큐가 비었을 때, 스레드를 대기 상태로 만든다.
• notify() : 생산자 또는 소비자가 대기 상태에서 깨어나게 하여 작업을 계속 수행할 수 있도록 한다.

 

5. 생산자-소비자 패턴의 장점

동시성 제어

생산자와 소비자가 동시에 데이터를 처리하더라도 동기화를 통해 데이터의 무결성을 보장할 수 있다.

효율적 자원 사용

버퍼의 크기를 제한해 메모리 자원의 사용을 제어할 수 있으며, 생산자와 소비자가 효율적으로 협력하여 작업을 처리할 수 있다.

멀리스레드 환경에서의 안정성

생산자와 소비자가 동기화된 방식으로 데이터를 처리하므로, 스레드 간의 충돌을 방지할 수 있다.

 

6. 생산자-소비자 패턴의 응용

이 패턴은 주로 다중 스레드 프로그래밍에서 사용되며, 다양한 상황에서 응용될 수 있다.

작업 대기열

생산자가 작업을 생성하고 소비자가 처리하는 작업 큐에서 사용된다.

메시지 처리 시스템

메시지를 생성하는 생산자와 그 메시지를 처리하는 소비자를 분리하여, 메시지 큐를 사용해 안전하게 메시지를 처리한다.

데이터 스트리밍

스트리밍 데이터의 생산자(데이터 제공자)와 소비자(데이터 처리자)가 협력하여 데이터를 실시간으로 처리할 수 있다.

 

결론

생산자-소비자 패턴은 멀티스레드 환경에서 데이터를 안전하게 공유하는 방법으로, 생산자 스레드 데이터를 생성하고 소비자 스레드가 그 데이터를 처리할 때 자주 사용된다. 이 패턴은 동시성 문제를 해결하며, BlockingQueue와 같은 동기화된 큐를 사용하면 복잡한 동기화 코드를 피할 수 있다.