IPC(Inter-Process Communication, 프로세스 간 통신)

 

 

 

IPC(Inter-Process Communication) 이란?

프로세스 간 통신(Inter-Process Communication, IPC)은 다른 프로세스 간에 데이터를 전송하거나 상호작용하기 위한 메커니즘을 말합니다. 다양한 IPC 기법이 존재하며, 각각의 기법은 다른 상황이나 요구에 맞게 선택되어 사용됩니다. 멀티스레드와 함께 멀티 프로세스의 데이터 전송 기술입니다.

 

다음은 대표적인 IPC 방법입니다.
1. 파이프(Pipes): 파이프는 한 프로세스가 데이터를 쓰고 다른 프로세스가 그 데이터를 읽을 수 있는 단방향 통신 메커니즘입니다. 부모 프로세스와 자식 프로세스 사이에서 주로 사용됩니다.

2. 명명된 파이프(Named Pipes): 명명된 파이프는 파일 시스템 내의 특별한 파일로 생성되며, 다른 프로세스 간에 양방향 통신을 가능하게 합니다. 여러 프로세스가 동시에 접근할 수 있습니다.

3. 메시지 큐(Message Queues): 메시지 큐는 프로세스 사이에 메시지를 비동기적으로 전달하는 기법입니다. 메시지 큐는 운영체제에서 제공하는 통신 매체로, 메시지를 보내고 받는 순서대로 메시지가 처리됩니다.

4. 공유 메모리(Shared Memory): 공유 메모리는 여러 프로세스가 동일한 메모리 영역을 공유하여 데이터를 직접 읽고 쓸 수 있는 기법입니다. 이는 빠른 데이터 교환을 가능하게 하지만 동기화와 관련된 문제를 주의해야 합니다.

5. 소켓(Sockets): 소켓은 네트워크를 통한 프로세스 간 통신을 가능하게 하는 기술입니다. 소켓을 사용하여 다른 컴퓨터 또는 같은 컴퓨터의 다른 프로세스와 데이터를 교환할 수 있습니다.

6. RPC(Remote Procedure Call): RPC는 원격 프로시저 호출을 통해 다른 컴퓨터나 프로세스에서 함수를 실행하고 결과를 받을 수 있는 기법입니다. 마치 로컬 함수 호출처럼 원격에서 함수를 호출할 수 있습니다.

7. 파일(Files): 파일을 사용하여 프로세스 간에 데이터를 공유하거나 통신하는 방법도 있습니다. 파일을 사용하여 데이터를 읽고 쓸 수 있으며, 파일 락(파일 잠금)을 사용하여 동기화를 할 수도 있습니다.

 

 

파이프(Pipe)

파이프(Pipe) 통신은 프로세스 간에 단방향으로 데이터를 전달하는 IPC(Inter-Process Communication) 메커니즘 중 하나입니다. 이는 운영체제에서 제공하는 특별한 파일 기반의 통신 방법으로, 주로 부모 프로세스와 자식 프로세스 간의 통신에 사용됩니다. 파이프는 데이터의 흐름이 일방향적이기 때문에 단일 방향으로 데이터를 전달하는 데 유용합니다.

파이프 통신의 주요 특징은 다음과 같습니다:

1. 단방향 통신: 파이프는 단방향 통신 메커니즘이므로 데이터의 흐름은 한 방향으로만 가능합니다. 데이터를 보내는 쪽과 받는 쪽이 분리되어 있습니다.

2. 부모-자식 프로세스 간 통신: 주로 부모 프로세스와 자식 프로세스 사이에서 사용됩니다. 부모 프로세스가 파이프를 생성하고, 자식 프로세스에서 이를 통해 데이터를 읽거나 쓸 수 있습니다.

3. 파일 기반 통신: 파이프는 파일처럼 취급되기 때문에 파일 디스크립터(File Descriptor)를 통해 열고 닫을 수 있습니다. 파이프의 읽기 측과 쓰기 측 각각에 대한 파일 디스크립터가 필요합니다.

4. 단순한 데이터 전달: 파이프는 단순히 데이터를 전달하기 위한 용도로 사용되며, 복잡한 구조의 데이터 전송은 어려울 수 있습니다.

 

파이프 통신은 다음과 같은 단계로 이루어집니다:

1. 파이프 생성: 부모 프로세스는 운영체제에게 파이프를 생성하도록 요청합니다.
2. 데이터 쓰기: 부모 프로세스는 생성된 파이프의 쓰기 측 파일 디스크립터를 사용하여 데이터를 쓸 수 있습니다.
3. 데이터 읽기: 자식 프로세스는 생성된 파이프의 읽기 측 파일 디스크립터를 사용하여 부모 프로세스가 보낸 데이터를 읽을 수 있습니다.

 

import os

def parent_child_communication():
    # 파이프 생성
    parent_pipe, child_pipe = os.pipe()

    # 자식 프로세스 생성
    pid = os.fork()

    if pid == 0:  # 자식 프로세스
        os.close(parent_pipe)  # 자식은 쓰기 측 닫음

        child_message = "Hello from child!"
        os.write(child_pipe, child_message.encode())  # 자식이 파이프를 통해 데이터 전송

        os.close(child_pipe)
    else:  # 부모 프로세스
        os.close(child_pipe)  # 부모는 읽기 측 닫음

        parent_message = os.read(parent_pipe, 1024).decode()  # 부모가 파이프를 통해 데이터 수신
        print("Parent received:", parent_message)

        os.close(parent_pipe)

parent_child_communication()

위 예제는 파이썬으로 부모 프로세스와 자식 프로세스 사이에서 파이프를 사용하여 간단한 문자열 데이터를 주고 받는 방법을 보여줍니다. os.pipe() 함수로 파이프를 생성하고, os.fork() 함수로 자식 프로세스를 생성합니다. 자식 프로세스는 파이프의 쓰기 측을 닫은 뒤 데이터를 전송하고, 부모 프로세스는 파이프의 읽기 측을 닫은 뒤 데이터를 수신합니다.

그리고 Named Pipe는 Pipe의 단점을 해결한, Pipe의 확장이라고 할 수 있습니다. Pipe가 이름을 가지기 때문에 이름만 알면 양방향 통신이 가능합니다. 다만 읽기/쓰기가 동시에 불가능하기 때문에 한쪽에서는 Read only, 한쪽에서는 Write only만 가능합니다.

파이프 통신은 단순한 데이터 전달을 위한 간단한 메커니즘이며, 여러 프로세스 간의 복잡한 통신을 위해서는 다른 IPC 기법들을 사용하는 것이 더 적합할 수 있습니다.

 

 

 

메세지 큐(Message Queue)

메시지 큐는 프로세스가 메시지를 생성하고 전송하여 다른 프로세스가 이를 수신하는 메커니즘입니다. 메시지 큐는 비동기적으로 데이터를 전달하므로, 데이터를 생산하는 프로세스와 데이터를 소비하는 프로세스가 실시간으로 동작하지 않아도 되는 상황에서 유용합니다.(파이프와 유사) 요약하면 비동기 단 방향 메세지 방식의 IPC라고 보면 될 것 같습니다.

 

메시지 큐의 주요 특징은 다음과 같습니다.

1. 비동기 통신: 메시지 큐는 데이터를 비동기적으로 전달합니다. 메시지를 생성하는 프로세스와 수신하는 프로세스가 실시간으로 동작하지 않아도 됩니다. 따라서 Producer-Consumer 패턴을 멀티 프로세스로 활용할 때 메세지 큐를 활용합니다. 데이터를 Producer가 Queue에 넣고 여러 개의 Consumer processes가 이를 처리하는 방식입니다.

2. 메시지 지향: 메시지 큐는 메시지 단위로 데이터를 전달합니다. 각 메시지는 데이터와 함께 메시지 식별자를 포함하며, 이를 통해 프로세스 간에 특정 형식의 메시지를 주고받을 수 있습니다.

3. 버퍼링: 메시지 큐는 내부적으로 버퍼를 사용하여 메시지를 저장하고 전달합니다. 이를 통해 메시지 소비자가 메시지를 즉시 처리하지 않더라도 데이터의 유실이나 지연을 방지할 수 있습니다.

4. 우선순위: 일부 메시지 큐 시스템은 메시지에 우선순위를 부여할 수 있습니다. 이를 통해 중요한 메시지를 먼저 처리하도록 조절할 수 있습니다.

 

아래는 파이썬의 multiprocessing 모듈을 사용한 메시지 큐 예제입니다.

from multiprocessing import Process, Queue

def producer(queue):
    for i in range(5):
        message = f"Message {i}"
        queue.put(message)
        print(f"Produced: {message}")

def consumer(queue):
    while True:
        message = queue.get()
        if message == 'STOP':
            break
        print(f"Consumed: {message}")

if __name__ == "__main__":
    message_queue = Queue()

    producer_process = Process(target=producer, args=(message_queue,))
    consumer_process = Process(target=consumer, args=(message_queue,))

    producer_process.start()
    consumer_process.start()

    producer_process.join()
    message_queue.put('STOP')  # 종료를 위한 특별한 메시지 전송
    consumer_process.join()

이 예제에서는 두 개의 프로세스를 생성하여 메시지 큐를 통해 데이터를 전달합니다. Queue 클래스를 사용하여 메시지 큐를 생성하고, 프로듀서 프로세스는 메시지를 생성하고 큐에 넣고, 컨슈머 프로세스는 큐에서 메시지를 꺼내 소비합니다. 종료를 위해 특별한 메시지 STOP을 전달하여 컨슈머 프로세스를 종료합니다.

 

 

 

공유메모리(Shared Memory)

공유 메모리(Shared Memory)는 다른 프로세스 간에 메모리 영역을 공유하여 데이터를 직접 주고 받는 메커니즘입니다. 이를 통해 데이터를 복사하거나 중간 매개체를 거치지 않고 빠르게 통신할 수 있습니다. 그러나 동기화와 관련된 문제에 유의해야 합니다.

 

공유 메모리 IPC의 주요 특징은 다음과 같습니다.

1. 빠른 데이터 전송: 공유 메모리를 사용하면 데이터를 직접 복사하지 않고 메모리 영역을 공유하기 때문에 데이터 전송 속도가 빠릅니다.

2. 간단한 구현: 일반적으로 메모리 맵핑(Memory Mapping) 기술을 사용하여 구현되며, 프로세스 간에 메모리를 공유하고 접근하는 것이 비교적 간단합니다.

3. 동기화 필요: 여러 프로세스가 공유 메모리를 동시에 접근할 때 동기화 문제가 발생할 수 있습니다. 이를 해결하기 위해 세마포어, 뮤텍스 등의 동기화 메커니즘을 사용해야 합니다.

아래는 파이썬의 multiprocessing 모듈을 사용하여 공유 메모리를 통한 데이터 교환 예제입니다:

from multiprocessing import Process, Value, Array

def writer(value, arr):
    value.value = 10
    for i in range(len(arr)):
        arr[i] = i * 2

def reader(value, arr):
    print("Value:", value.value)
    print("Array:", arr[:])

if __name__ == "__main__":
    shared_value = Value('i', 0)  # 정수형 공유 변수
    shared_array = Array('i', range(10))  # 정수형 배열

    writer_process = Process(target=writer, args=(shared_value, shared_array))
    reader_process = Process(target=reader, args=(shared_value, shared_array))

    writer_process.start()
    writer_process.join()

    reader_process.start()
    reader_process.join()

이 예제에서는 공유 변수(Value)와 공유 배열(Array)을 사용하여 공유 메모리를 만듭니다. 프로듀서 프로세스(writer)는 공유 변수와 배열에 데이터를 저장하고, 컨슈머 프로세스(reader)는 공유 변수와 배열의 데이터를 읽습니다. 데이터가 공유 메모리를 통해 직접 주고받는 것을 확인할 수 있습니다.

 

 

 

소켓(Socket)

소켓(Socket) 통신은 네트워크를 통해 프로세스 간 통신을 가능하게 하는 IPC(Inter-Process Communication)의 한 형태입니다. 소켓을 사용하면 다른 컴퓨터나 같은 컴퓨터의 다른 프로세스와 데이터를 주고받을 수 있습니다. 소켓을 이용한 통신은 클라이언트-서버 모델로 작동하며, 네트워크 상에서 데이터를 전송하고 수신하는 기능을 제공합니다.

 

출처: https://12bme.tistory.com/228

 

소켓 통신의 특징입니다.

1. 네트워크 통신: 소켓은 네트워크를 통해 데이터를 주고받을 수 있습니다. 따라서 서로 다른 컴퓨터 간의 통신이 가능합니다.

2. 클라이언트-서버 모델: 일반적으로 클라이언트는 서버에 요청을 보내고, 서버는 클라이언트의 요청을 처리하여 결과를 반환합니다.

3. 프로토콜 지정: 소켓 통신에는 여러 프로토콜(예: TCP, UDP)을 사용할 수 있습니다. TCP는 신뢰성 있는 연결 지향 통신을 제공하며, UDP는 비연결성 프로토콜로 데이터 전송 속도가 빠릅니다.

4. 동기 및 비동기 통신: 소켓 통신은 동기적인 방식과 비동기적인 방식을 모두 지원합니다. 동기 통신은 데이터 송수신이 블로킹될 수 있지만, 비동기 통신은 블로킹되지 않고 동시에 여러 작업을 처리할 수 있습니다.

아래는 파이썬의 socket 모듈을 사용하여 클라이언트와 서버 간의 소켓 통신 예제입니다.

서버 측

import socket

def server():
    server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server_socket.bind(("127.0.0.1", 12345))
    server_socket.listen(1)
    print("Server is listening...")

    conn, addr = server_socket.accept()
    print("Connected by", addr)

    data = conn.recv(1024).decode()
    print("Received:", data)
    
    conn.send("Hello from server!".encode())
    conn.close()

server()

클라이언트 측

import socket

def client():
    client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    client_socket.connect(("127.0.0.1", 12345))

    client_socket.send("Hello from client!".encode())
    data = client_socket.recv(1024).decode()
    print("Received:", data)
    
    client_socket.close()

client()

이 예제에서 서버는 socket 모듈을 사용하여 소켓을 생성하고 바인딩한 뒤 클라이언트의 연결을 기다립니다. 클라이언트는 서버에 연결한 뒤 메시지를 보내고 서버로부터 응답을 받습니다.

 

소켓 통신은 다른 시스템간 양 방향 통신이 가능합니다. 파이프, 메세지 큐, 공유메모리는 모두 같은 시스템(컴퓨터) 내 다른 프로세스 끼리의 통신만 가능하다면, 소켓의 경우 네트워크를 활용하여 외부 시스템과도 통신이 가능합니다. HTTP를 활용한 웹 통신 또한 소켓 통신이라고 보면 됩니다. 다만 IPC에서의 소켓 통신은 HTTP에 국한되지 않으며 다양한 프로토콜을 통해 데이터를 전송합니다.

 

RPC와 Kafka등 살짝 응용기술은 따로 다루도록 하겠습니다.😊