이 게시글은 혼공학습단(혼공컴운) 14기의 3주차 과제를 포함하고 있습니다.

RAID란 무엇인가요?

RAID는 'Redundant Array of Independent Disks'의 줄임말로, 독립적인 여러 개의 디스크를 마치 하나의 큰 디스크처럼 작동하게 만드는 기술입니다. 단순히 디스크를 합치는 것을 넘어, 데이터를 여러 디스크에 분산 저장하거나 복사본을 만들어 보관함으로써 다음과 같은 이점을 제공합니다.

• 데이터 안전성 향상: 디스크 하나가 고장 나더라도 데이터를 보호하고 복구할 수 있습니다.
• 성능 향상: 여러 디스크가 동시에 작동하여 데이터 읽기/쓰기 속도를 높일 수 있습니다.

예를 들어, 1TB 하드디스크 4개를 RAID로 구성하면 단순히 4TB 하나의 하드디스크를 사용하는 것보다 훨씬 뛰어난 성능과 안전성을 기대할 수 있습니다.

다양한 RAID 레벨: 목적에 맞는 선택

RAID는 구성 방식에 따라 여러 '레벨'로 나뉘며, 각 레벨마다 장단점이 명확합니다. 주요 RAID 레벨을 살펴보겠습니다.

1. RAID 0 (스트라이핑): 속도에 올인!

• 작동 방식: 데이터를 여러 디스크에 블록 단위로 나누어 동시에 저장합니다.
• 장점: 여러 디스크에서 동시에 읽고 쓰기 때문에 압도적인 입출력 속도 향상을 경험할 수 있습니다.
• 단점: 디스크 중 단 하나라도 고장 나면 모든 데이터를 잃을 수 있어 데이터 안전성이 매우 낮습니다.

2. RAID 1 (미러링): 데이터 안전이 최우선!

• 작동 방식: 원본 데이터를 다른 디스크에 완벽하게 복사하여 저장합니다. 마치 거울처럼 데이터를 복제한다고 해서 '미러링'이라고 불립니다.
• 장점: 디스크 하나가 고장 나도 복사본이 있어 데이터 복구 및 안전성이 매우 높습니다.
• 단점: 원본과 복사본에 동시에 데이터를 써야 하므로 쓰기 속도가 느릴 수 있으며, 동일한 데이터를 두 번 저장하기 때문에 실제 사용 가능한 용량이 절반으로 줄어들어 비용 효율성이 낮습니다.

3. RAID 4: 패리티를 활용한 효율적인 안전성

• 작동 방식: 완전한 복사본 대신, 오류 검출 및 복구 정보인 '패리티 비트'를 별도의 디스크에 저장합니다.
• 장점: RAID 1보다 적은 디스크로도 데이터를 안전하게 보관할 수 있습니다.
• 단점: 패리티 정보를 저장하는 디스크에 모든 쓰기 작업이 집중되어 병목 현상이 발생할 수 있습니다.

4. RAID 5: RAID 4의 단점 보완

• 작동 방식: RAID 4의 단점인 패리티 디스크의 병목 현상을 해결하기 위해 패리티 정보를 여러 디스크에 분산하여 저장합니다.
• 장점: RAID 4보다 효율적이며, 데이터 안전성과 성능의 균형이 좋습니다.

5. RAID 6: 더욱 강력한 데이터 보호

• 작동 방식: 두 가지 종류의 패리티 정보를 사용하여 오류 검출 및 복구 능력을 한층 강화합니다.
• 장점: RAID 5보다 데이터 안전성이 더욱 높습니다. 디스크 두 개가 동시에 고장 나도 데이터를 보호할 수 있습니다.
• 단점: 두 종류의 패리티 정보를 써야 하므로 쓰기 속도가 RAID 5보다 느릴 수 있습니다.

3주차 숙제

이 게시글은 혼공학습단(혼공컴운) 14기의 2주차 과제를 포함하고 있습니다.

기본 개념부터 시작하기

코어(Core)란?

코어는 CPU 내부에서 실제로 연산을 수행하는 물리적인 처리 단위입니다. 쉽게 말해, 코어는 컴퓨터의 "두뇌"라고 할 수 있습니다. 하나의 코어는 한 번에 하나의 명령어를 실행할 수 있습니다.

과거에는 하나의 CPU에 하나의 코어만 있었지만, 기술이 발전하면서 하나의 CPU 칩 안에 여러 개의 코어를 집적할 수 있게 되었습니다. 이를 멀티 코어 프로세서라고 합니다.

일상생활 비유: 코어를 요리사라고 생각해보세요. 한 명의 요리사(싱글 코어)는 한 번에 하나의 요리만 만들 수 있지만, 여러 명의 요리사(멀티 코어)가 있으면 동시에 여러 요리를 만들 수 있습니다.

스레드(Thread)란?

스레드는 프로그램 내에서 실행되는 작업의 단위입니다. 하나의 프로세스 안에서 여러 개의 스레드가 동시에 실행될 수 있습니다. 스레드는 소프트웨어적인 개념으로, 실제 물리적인 코어에서 실행됩니다.

일상생활 비유: 스레드를 요리 레시피라고 생각해보세요. 한 명의 요리사(코어)가 여러 개의 레시피(스레드)를 번갈아가며 실행할 수 있습니다. 파스타를 끓이는 동안 샐러드를 만들고, 샐러드를 만드는 동안 소스를 준비하는 것처럼 말이죠.

하드웨어 스레드 vs 소프트웨어 스레드

여기서 중요한 구분을 해야 합니다:

하드웨어 스레드 (Hardware Thread)

하드웨어 스레드는 물리적 코어가 동시에 처리할 수 있는 명령어 스트림의 개수입니다. 인텔의 하이퍼스레딩(Hyper-threading) 기술이나 AMD의 SMT(Simultaneous Multithreading) 기술을 통해 하나의 물리적 코어가 두 개의 하드웨어 스레드를 지원할 수 있습니다.

소프트웨어 스레드 (Software Thread)

소프트웨어 스레드는 프로그램에서 생성하는 실행 단위입니다. 운영체제가 이 소프트웨어 스레드들을 하드웨어 스레드에 할당하여 실행합니다.

멀티 코어 시스템의 이해

멀티 코어란?

멀티 코어는 하나의 CPU 칩 안에 여러 개의 물리적 코어가 있는 것을 의미합니다. 현재 대부분의 컴퓨터는 최소 듀얼 코어(2개)부터 시작해서 많게는 수십 개의 코어를 가지고 있습니다.

멀티 코어의 장점:

• 진정한 병렬 처리: 각 코어가 독립적으로 작업을 수행할 수 있어 실제로 동시에 여러 작업이 실행됩니다.
• 전력 효율성: 클럭 속도를 높이는 것보다 코어 수를 늘리는 것이 전력 소비 측면에서 더 효율적입니다.
• 열 관리: 여러 코어가 작업을 분산하므로 열 발생이 분산됩니다.

멀티 코어 시스템에서의 작업 분배

멀티 코어 시스템에서는 운영체제의 스케줄러가 프로세스와 스레드를 각 코어에 할당합니다. 이 과정에서 다음과 같은 요소들이 고려됩니다:

• 부하 분산: 각 코어의 작업량을 균등하게 맞춤
• 캐시 지역성: 데이터 캐시의 효율성을 위해 관련 작업을 같은 코어에 할당
• 스레드 친화성: 특정 스레드를 특정 코어에 고정시키는 기법

멀티 스레드 프로그래밍

멀티 스레드란?

멀티 스레드는 하나의 프로그램 내에서 여러 개의 스레드가 동시에 실행되는 것을 의미합니다. 이는 프로그램의 성능을 향상시키고 사용자 경험을 개선하는 중요한 기법입니다.

멀티 스레드의 장점

응답성 향상: 사용자 인터페이스 스레드가 별도로 실행되므로 프로그램이 멈춘 것처럼 보이지 않습니다.

자원 공유: 같은 프로세스 내의 스레드들은 메모리 공간을 공유하므로 데이터 교환이 효율적입니다.

경제성: 새로운 프로세스를 생성하는 것보다 스레드를 생성하는 것이 시스템 자원을 덜 소모합니다.

멀티 스레드 프로그래밍 예시

// TypeScript에서의 멀티 스레드 예시 (Worker 사용)
class DownloadManager {
    private downloadFile(filename: string): Promise<string> {
        return new Promise((resolve) => {
            console.log(`다운로드 시작: ${filename}`);

            // 다운로드 시뮬레이션 - 실제로는 네트워크 요청
            setTimeout(() => {
                console.log(`다운로드 완료: ${filename}`);
                resolve(`${filename} 다운로드 성공`);
            }, 2000);
        });
    }

    // 여러 파일을 동시에 다운로드하는 메서드
    async downloadMultipleFiles(filenames: string[]): Promise<string[]> {
        // Promise.all을 사용하여 모든 다운로드를 동시에 시작
        const downloadPromises = filenames.map(filename => 
            this.downloadFile(filename)
        );

        // 모든 다운로드가 완료될 때까지 대기
        return await Promise.all(downloadPromises);
    }
}

// 사용 예시
async function main() {
    const downloader = new DownloadManager();
    const files = ['파일1.zip', '파일2.zip', '파일3.zip'];

    try {
        // 모든 파일을 동시에 다운로드 시작
        const results = await downloader.downloadMultipleFiles(files);
        console.log('모든 다운로드 완료:', results);
    } catch (error) {
        console.error('다운로드 중 오류:', error);
    }
}

main();

코어와 스레드의 관계

1:1 관계가 아닌 이유

많은 사람들이 착각하는 것 중 하나는 "4코어 CPU는 4개의 스레드만 실행할 수 있다"는 것입니다. 하지만 실제로는 그렇지 않습니다.

운영체제의 스케줄링: 운영체제는 시분할 시스템을 사용하여 매우 짧은 시간 간격으로 스레드들을 교체하면서 실행합니다. 이로 인해 수백 개의 스레드가 동시에 실행되는 것처럼 보입니다.

컨텍스트 스위칭: 스레드 간 전환을 컨텍스트 스위칭이라고 하며, 이 과정에서 CPU 레지스터의 값들이 저장되고 복원됩니다.

최적의 스레드 개수

일반적으로 CPU 집약적인 작업의 경우 "코어 수 = 스레드 수"가 가장 효율적입니다. 하지만 I/O 작업이 많은 경우에는 더 많은 스레드를 사용하는 것이 유리할 수 있습니다.

// 최적 스레드 개수 계산 예시
class ThreadPoolManager {
    private readonly availableProcessors: number;

    constructor() {
        // Node.js에서 사용 가능한 CPU 코어 수 확인
        this.availableProcessors = require('os').cpus().length;
    }

    // CPU 집약적 작업을 위한 스레드 풀 크기
    getCpuIntensiveThreadCount(): number {
        return this.availableProcessors;
    }

    // I/O 집약적 작업을 위한 스레드 풀 크기
    getIoIntensiveThreadCount(): number {
        return this.availableProcessors * 2;
    }

    // 혼합 작업을 위한 적응형 스레드 풀 크기
    getAdaptiveThreadCount(ioRatio: number): number {
        return Math.floor(this.availableProcessors * (1 + ioRatio));
    }
}

// 사용 예시
const threadManager = new ThreadPoolManager();
console.log(`CPU 집약적 작업 스레드 수: ${threadManager.getCpuIntensiveThreadCount()}`);
console.log(`I/O 집약적 작업 스레드 수: ${threadManager.getIoIntensiveThreadCount()}`);

동시성 vs 병렬성

동시성(Concurrency)

동시성은 여러 작업이 논리적으로 동시에 실행되는 것처럼 보이는 것입니다. 싱글 코어 시스템에서도 시분할을 통해 동시성을 구현할 수 있습니다.

병렬성(Parallelism)

병렬성은 여러 작업이 물리적으로 동시에 실행되는 것입니다. 이는 멀티 코어 시스템에서만 가능합니다.

핵심 차이점: 동시성은 "동시에 다루는 것"이고, 병렬성은 "동시에 실행하는 것"입니다.

실제 개발에서의 고려사항

1. 스레드 안전성 (Thread Safety)

여러 스레드가 공유 자원에 접근할 때 발생할 수 있는 문제를 방지해야 합니다.

// 스레드 안전하지 않은 예시
class UnsafeCounter {
    private count: number = 0;

    // 여러 스레드가 동시에 실행하면 경쟁 조건(race condition) 발생 가능
    increment(): void {
        this.count++; // 읽기 -> 증가 -> 쓰기 과정이 원자적이지 않음
    }

    getCount(): number {
        return this.count;
    }
}

// 스레드 안전한 예시 (뮤텍스 패턴 사용)
class SafeCounter {
    private count: number = 0;
    private mutex: boolean = false; // 간단한 뮤텍스 구현

    // 동기화를 통해 한 번에 하나의 스레드만 접근 가능
    async increment(): Promise<void> {
        // 뮤텍스 획득 대기
        while (this.mutex) {
            await new Promise(resolve => setTimeout(resolve, 1));
        }

        this.mutex = true; // 뮤텍스 잠금
        try {
            this.count++; // 임계 구역
        } finally {
            this.mutex = false; // 뮤텍스 해제
        }
    }

    getCount(): number {
        return this.count;
    }
}

// 더 현대적인 방법: Promise 기반 큐를 사용한 동기화
class ModernSafeCounter {
    private count: number = 0;
    private operationQueue: Promise<void> = Promise.resolve();

    increment(): Promise<void> {
        // 모든 증가 연산을 순차적으로 실행하도록 큐에 추가
        this.operationQueue = this.operationQueue.then(() => {
            this.count++;
        });
        return this.operationQueue;
    }

    getCount(): number {
        return this.count;
    }
}

2. 데드락 (Deadlock)

두 개 이상의 스레드가 서로 다른 스레드가 점유한 자원을 기다리며 무한정 대기하는 상황입니다.

3. 성능 최적화

CPU 바운드 작업: 코어 수만큼 스레드를 생성하는 것이 최적입니다.

I/O 바운드 작업: 대기 시간이 많으므로 코어 수보다 더 많은 스레드를 사용할 수 있습니다.

최신 동향과 미래 전망

하이퍼스레딩과 SMT

인텔의 하이퍼스레딩과 AMD의 SMT 기술은 하나의 물리적 코어가 두 개의 논리적 코어로 작동하게 합니다. 이를 통해 코어 활용률을 높일 수 있습니다.

이기종 멀티 코어

ARM의 big.LITTLE 아키텍처처럼 성능 코어와 효율 코어를 결합한 설계가 모바일 기기에서 주목받고 있습니다.

비동기 프로그래밍

최근에는 스레드 대신 비동기 프로그래밍 패턴을 사용하는 추세입니다. 이는 적은 스레드로도 높은 동시성을 달성할 수 있게 해줍니다.

// 비동기 프로그래밍 예시
class AsyncTaskManager {
    // 여러 비동기 작업을 동시에 처리
    async processMultipleTasks(): Promise<void> {
        // 각 작업을 비동기적으로 실행
        const task1 = this.processData("데이터1");
        const task2 = this.processData("데이터2");
        const task3 = this.processData("데이터3");

        // 모든 작업이 완료될 때까지 대기
        const results = await Promise.all([task1, task2, task3]);

        console.log('모든 작업 완료:', results);
    }

    // 개별 비동기 작업
    private async processData(data: string): Promise<string> {
        return new Promise((resolve) => {
            // 비동기 작업 시뮬레이션
            setTimeout(() => {
                console.log(`${data} 처리 완료`);
                resolve(`${data} 결과`);
            }, Math.random() * 1000);
        });
    }

    // 순차적 처리 vs 병렬 처리 비교
    async sequentialProcessing(items: string[]): Promise<string[]> {
        const results: string[] = [];

        // 순차적 처리 - 각 작업이 끝날 때까지 다음 작업 대기
        for (const item of items) {
            const result = await this.processData(item);
            results.push(result);
        }

        return results;
    }

    async parallelProcessing(items: string[]): Promise<string[]> {
        // 병렬 처리 - 모든 작업을 동시에 시작
        const promises = items.map(item => this.processData(item));
        return await Promise.all(promises);
    }
}

// Worker를 사용한 진정한 멀티 스레드 구현
class WorkerManager {
    private workerPool: Worker[] = [];
    private taskQueue: Array<{
        data: any;
        resolve: (result: any) => void;
        reject: (error: Error) => void;
    }> = [];

    constructor(workerCount: number) {
        // 워커 풀 초기화
        for (let i = 0; i < workerCount; i++) {
            const worker = new Worker('./worker.js');
            worker.onmessage = (event) => {
                this.handleWorkerMessage(event);
            };
            this.workerPool.push(worker);
        }
    }

    // 작업을 워커에게 할당
    async executeTask(data: any): Promise<any> {
        return new Promise((resolve, reject) => {
            const availableWorker = this.workerPool.find(w => !w.busy);

            if (availableWorker) {
                this.assignTaskToWorker(availableWorker, data, resolve, reject);
            } else {
                // 사용 가능한 워커가 없으면 큐에 추가
                this.taskQueue.push({ data, resolve, reject });
            }
        });
    }

    private assignTaskToWorker(
        worker: Worker & { busy?: boolean },
        data: any,
        resolve: (result: any) => void,
        reject: (error: Error) => void
    ): void {
        worker.busy = true;
        worker.postMessage(data);

        // 워커 응답 처리 (실제 구현에서는 더 복잡한 메시지 매칭 필요)
        worker.onmessage = (event) => {
            worker.busy = false;
            resolve(event.data);

            // 큐에 대기 중인 작업이 있으면 할당
            if (this.taskQueue.length > 0) {
                const nextTask = this.taskQueue.shift()!;
                this.assignTaskToWorker(worker, nextTask.data, nextTask.resolve, nextTask.reject);
            }
        };
    }

    private handleWorkerMessage(event: MessageEvent): void {
        // 워커로부터 메시지 처리
        console.log('워커에서 결과 수신:', event.data);
    }
}

2주차 숙제

개념 설명

▶ 스택 (Stack)

• 정의: 스택은 뒤로 넣고 뒤로 금방하는 (Last-In First-Out, LIFO) 구조.
• 복소 가능 작업:
  • push: 인접 값을 스택의 끝에 추가
  • pop: 스택의 끝에서 값 개발 (제거)
• 특징:
  • 매우 간단하고 다른 자료구 구성의 기원이 되기도 함
  • 불필요한 값 감지 불가 (LIFO)

▶ 큐 (Queue)

• 정의: 큐는 지난시점에 넣고 지나지 않은 순서대로 가지고 가는 (First-In First-Out, FIFO) 구조.
• 복소 가능 작업:
  • enqueue: 값을 큐 끝에 추가
  • dequeue: 큐 첫번째 값 개발 (제거)
• 특징:
  • 일정 순서대로 값 처리
  • 역순서처리 불가

TypeScript로 스택 구현

// 스택 구현
class Stack<T> {
  private items: T[] = [];

  // push: 값을 뒤에 넣기
  push = (item: T): void => {
    this.items.push(item);
  };

  // pop: 뒤에서 값 개발
  pop = (): T | undefined => {
    return this.items.pop();
  };

  // peek: 최근 값
  peek = (): T | undefined => {
    return this.items[this.items.length - 1];
  };

  // isEmpty: 빈 상태 확인
  isEmpty = (): boolean => {
    return this.items.length === 0;
  };
}

TypeScript로 큐 구현

// 큐 구현
class Queue<T> {
  private items: T[] = [];

  // enqueue: 끝에 값 추가
  enqueue = (item: T): void => {
    this.items.push(item);
  };

  // dequeue: 첫번째 값 개발
  dequeue = (): T | undefined => {
    return this.items.shift();
  };

  // front: 첫번째 값 확인
  front = (): T | undefined => {
    return this.items[0];
  };

  // isEmpty: 빈 상태 확인
  isEmpty = (): boolean => {
    return this.items.length === 0;
  };
}

사용 예제

const stack = new Stack<number>();
stack.push(10);
stack.push(20);
console.log(stack.pop()); // 20

const queue = new Queue<string>();
queue.enqueue("A");
queue.enqueue("B");
console.log(queue.dequeue()); // "A"

1주차 숙제

이 게시글은 혼공학습단(혼공파) 13기의 6주차 과제를 포함하고 있습니다.

Flask와 BeautifulSoup 간단 소개 

Flask는 가벼운 웹 프레임워크로 간단한 웹 애플리케이션을 빠르게 개발할 수 있는 도구입니다.  

BeautifulSoup은 HTML/XML을 파싱하여 웹 크롤링을 쉽게 할 수 있도록 도와주는 라이브러리입니다. 

from flask import Flask
from urllib import request
from bs4 import BeautifulSoup

class WeatherScraper:
  """기상청 날씨 데이터를 가져와 처리하는 클래스"""

  def __init__(self, url: str):
    """생성자: 가져올 URL을 설정"""
    self.url = url
    self.soup = None

  def fetch_weather_data(self):
    """웹에서 데이터를 가져와 BeautifulSoup으로 분석"""
    response = request.urlopen(self.url)
    self.soup = BeautifulSoup(response, "html.parser")

  # 파일로 저장하는 이유는 디버그 용도
  # print()함수로 사용해서 확인하니까 너무 길어서 짤림...
  def save_to_file(self, filename: str = "result.html"):
    """파싱된 데이터를 파일로 저장"""
    if self.soup:
      with open(filename, "w", encoding="utf-8") as file:
        file.write(str(self.soup))

  def parse_weather(self) -> str:
    """HTML 문서 전체를 생성하여 반환"""

    if not self.soup:
      return "<p>날씨 데이터를 불러오지 못했습니다.</p>"

    output = """
    <!DOCTYPE html>
    <html lang="ko">
    <head>
      <meta charset="UTF-8">
      <meta name="viewport" content="width=device-width, initial-scale=1.0">
      <title>[혼공파] - 6주차 과제</title>
      <style>
        body { font-family: Arial, sans-serif; margin: 20px; }
        h1 { color: darkblue; }
        h3 { color: darkred; }
        hr { border: 0; height: 1px; background: gray; margin: 10px 0; }
      </style>
    </head>
    <body>
      <h1>[혼공파] 6주차 마지막 과제</h1>
    """

    # header 태그 가져오기 (존재하면 출력)
    header_tag = self.soup.select("header")
    # html이니까 br 태그로 줄 바꿈 해주기
    # select는 return 타입이 array임
    header_text = "<br />".join([tag.get_text(strip=True) for tag in header_tag]) if header_tag else "헤더 정보 없음"

    output += f"<strong>{header_text}</strong><hr/>"

    # 지역별 날씨 정보 추가
    # location 별로 나눠져 있음
    for location in self.soup.select("location"):
      city = location.select_one("city").string
      weather = location.select_one("wf").string
      min_temp = location.select_one("tmn").string
      max_temp = location.select_one("tmx").string

      output += f"<h3>{city}</h3>"
      output += f"<p>날씨: {weather}</p>"
      output += f"<p>최저/최고 기온: {min_temp}/{max_temp}</p>"
      output += "<hr />"

    # HTML 마무으리
    output += """
    </body>
    </html>
    """

    return output

# Flask 웹 서버 생성
app = Flask(__name__)

# 루트 경로로 실행
@app.route("/")
def hello():
  """Flask 라우트에서 WeatherScraper(클래스)를 활용하여 HTML 반환"""
  scraper = WeatherScraper("http://www.kma.go.kr/weather/forecast/mid-term-rss3.jsp?stnId=108")
  scraper.fetch_weather_data()
  scraper.save_to_file()  # result.html 파일 저장
  return scraper.parse_weather()  # HTML 문서 전체 반환

기본 숙제 코드 beautiful_flask.py 와 다른 점

• WeatherScraper 클래스를 사용하여 데이터를 가져오고 파싱하는 기능을 모듈화했습니다.
• 지역, 날씨, 최저/최고 기온 데이터 외에 HTML <head> 태그와 RSS에 있는 <header> 데이터를 포함했습니다.
• print()를 사용해서 데이터를 확인하려 했지만, 응답 컨텐츠가 너무 길어 파일로 저장하여 디버깅했습니다.

export FLASK_APP=<파일명>.py # ./beautiful_soup
flask run
http://127.0.0.1:5000

결과

이 게시글은 혼공학습단(혼공파) 13기의 5주차 과제를 포함하고 있습니다.

어떤 언어로든 프로그래밍을 하다 보면 구문 오류(SyntaxError)와 예외(Exception)를 자주 만나게 됩니다. 이 둘은 모두 코드 실행을 멈추게 만들지만, 발생 원인과 처리 방식이 다릅니다. 이번 글에서는 구문 오류와 예외의 차이를 이해하고, 이를 효과적으로 처리하는 방법을 살펴보겠습니다.

1. 구문 오류(SyntaxError)란?

구문 오류(SyntaxError)는 코드가 문법적으로 올바르지 않을 때 발생하는 오류입니다. 파이썬 인터프리터는 실행 전에 구문 분석(parsing) 과정을 거치는데, 이때 문법에 맞지 않는 코드가 발견되면 SyntaxError가 발생하며 실행이 중단됩니다. 주로 IDE의 코드 빨간줄인 경우 구문 오류 입니다.

주요 구문 오류 종류

• SyntaxError: 문법 오류
• IndentationError: 들여쓰기 오류
• TabError: 탭과 공백 혼용 오류
• EOL while scanning string literal: 문자열 리터럴이 닫히지 않았을 때 발생
• Unexpected character after line continuation character: 줄바꿈 문자(\) 이후 잘못된 문자가 올 때 발생
• Invalid syntax: 잘못된 문법 구조 사용 시 발생

2. 예외(Exception)란?

예외(Exception)는 코드가 문법적으로는 올바르지만, 실행 도중 발생하는 오류입니다. 예를 들어, 0으로 나누거나 존재하지 않는 파일을 열려고 하면 예외가 발생합니다. 하지만 예외는 try-except 문을 사용해 적절히 처리할 수 있습니다.

주요 예외 종류

• ZeroDivisionError: 0으로 나누기 오류
• FileNotFoundError: 존재하지 않는 파일을 열려 할 때 발생
• TypeError: 잘못된 타입의 연산 수행
• ValueError: 부적절한 값을 함수에 전달했을 때 발생
• IndexError: 리스트 또는 튜플의 범위를 초과했을 때 발생
• KeyError: 딕셔너리에 존재하지 않는 키를 참조할 때 발생
• AttributeError: 존재하지 않는 속성을 접근하려 할 때 발생
• NameError: 정의되지 않은 변수를 참조했을 때 발생
• ImportError: 모듈 임포트 실패
• RuntimeError: 일반적인 실행 중 오류

3. 구문 오류와 예외의 주요 차이점

구분 구문 오류(SyntaxError) 예외(Exception)

4. 예시

# SyntaxError 예제
# 문법적으로 잘못된 코드 예시 (괄호 닫기 누락)
# 이 코드는 실행 자체가 되지 않음
# print("Hello"  

# 올바른 예제
print("Hello")  # 정상 실행

# 예외(Exception) 예제
# 실행 중 발생하는 오류는 try-except로 처리 가능
try:
    result = 10 / 0  # ZeroDivisionError 발생
except ZeroDivisionError as e:
    print(f"예외 발생: {e}")

try:
    numbers = [1, 2, 3]
    print(numbers[5])  # IndexError 발생 (범위를 초과한 인덱스 접근)
except IndexError as e:
    print(f"예외 발생: {e}")

try:
    value = int("hello")  # ValueError 발생 (문자열을 숫자로 변환 실패)
except ValueError as e:
    print(f"예외 발생: {e}")
    
try:
    x = int("hello")  # ValueError 발생
except Exception as e:  # 모든 예외를 처리하는 기본 예외 클래스
    print(f"예외 발생: {e}")

예외 처리는 크게 두 가지 방식으로 접근할 수 있습니다.

1. 구체적인 예외를 명시적으로 처리하는 방법
   • 특정 예외를 따로 처리하여 원인을 명확하게 파악할 수 있음.
   • 예외별로 다른 대응이 가능함.
2. Exception을 사용해 한 번에 처리하는 방법
   • 다양한 예외를 일괄적으로 잡아 코드가 간결해짐.
   • 예상치 못한 예외도 처리할 수 있음.

이러한 구조는 if, elif, else 문법과 비슷하게 이해할 수 있습니다.
즉, 명시적으로 예외를 처리하고 (if, elif) 마지막에 Exception을 설정해 두면 (else) 예상치 못한 예외 상황을 대비할 수 있습니다.

5. 결론

파이썬에서 구문 오류(SyntaxError)는 코드 실행 전에 문법적으로 잘못되었을 때 발생하며, try-except로 처리할 수 없습니다. 반면, 예외(Exception)는 실행 중 발생하는 오류이며, try-except를 사용해 적절히 처리할 수 있습니다.

이 게시글은 혼공학습단(혼공파) 13기의 4주차 과제를 포함하고 있습니다.

Python에서는 함수를 정의할 때 매개변수를 활용하여 다양한 방식으로 값을 전달할 수 있습니다. 본 글에서는 일반 매개변수, 기본 매개변수, 가변 매개변수에 대해 알아보고 각각의 예제와 함께 설명하겠습니다.

1. 매개변수 (Parameters)란?

매개변수는 함수를 정의할 때 함수가 외부에서 값을 받을 수 있도록 설정하는 변수입니다. 함수를 호출할 때 매개변수에 값을 전달하면 함수 내부에서 해당 값을 활용할 수 있습니다.

# 두 수를 더하는 함수 정의
def add(a, b):
    return a + b

# 함수 호출
result = add(3, 5)
print(result)  # 출력: 8

위 코드에서 a와 b는 매개변수이며, 함수가 호출될 때 3과 5가 각각 a, b에 전달됩니다.

2. 기본 매개변수 (Default Parameters)

기본 매개변수란 특정 인자를 전달하지 않았을 때 기본값을 사용할 수 있도록 설정된 매개변수입니다.

# 기본값을 가지는 함수 정의
def greet(name="Minions"):
    print(f"Hello, {name}!")

# 매개변수 값을 전달하는 경우
greet("Bob")  # 출력: Hello, Bob!

# 매개변수를 전달하지 않는 경우
greet()  # 출력: Hello, Minions!

위 코드에서 name 매개변수의 기본값을 "Minions"로 설정하여 인자를 전달하지 않아도 기본적으로 "Minions"가 출력됩니다.

3. 가변 매개변수 (*args, **kwargs)

3.1 가변 위치 매개변수 (*args)

*args는 여러 개의 위치 인자를 받을 수 있도록 하는 매개변수입니다.

# 여러 개의 숫자를 더하는 함수
def add_all(*args):
    return sum(args)

print(add_all(1, 2, 3))  # 출력: 6
print(add_all(4, 5, 6, 7, 8))  # 출력: 30

*args는 튜플 형태로 여러 개의 인자를 받아 처리할 수 있습니다.

3.2 가변 키워드 매개변수 (**kwargs)

**kwargs는 여러 개의 키워드 인자를 받을 수 있도록 하는 매개변수입니다.

# 사용자 정보를 출력하는 함수
def user_info(**kwargs):
    for key, value in kwargs.items():
        print(f"{key}: {value}")

user_info(name="Minions", eat="Banana", color="Yellow")

# 결과
# name: Minions
# eat: Banana
# color: Yellow

**kwargs는 딕셔너리 형태로 여러 개의 키워드 인자를 받아 처리할 수 있습니다.

4. 매개변수 조합하기

Python에서는 일반 매개변수, 기본 매개변수, 가변 매개변수를 조합하여 사용할 수 있습니다. 하지만 올바른 순서로 정의해야 합니다.

# 다양한 매개변수를 조합한 함수
def custom_function(a, b=10, *args, **kwargs):
    print(f"a: {a}")
    print(f"b: {b}")
    print(f"args: {args}")
    print(f"kwargs: {kwargs}")

custom_function(5, 20, 1, 2, 3, name="Minions", age=28)

# 결과
# a: 5
# b: 20
# args: (1, 2, 3)
# kwargs: {'name': 'Minions', 'age': 28}

위 코드에서는 위치 인자, 기본 인자, 가변 위치 인자, 가변 키워드 인자를 모두 사용할 수 있도록 설정했습니다.

여기서부터는 혼공파의 4주차 과제입니다.

p. 287 [직접 해보는 손코딩: 범위 내부의 정수를 모두 더하는 함수] 실행 후 코드가 입력된 화면 및 실행 결과 화면 캡처하기

# 함수를 선언합니다.
def sum_all(start, end):
    # 변수를 선언합니다.
    output = 0
    # 반복문을 돌려 숫자를 더합니다.
    for i in range(start, end + 1):
        output += i
    # 리턴합니다.
    return output
    

# 함수를 호출합니다.
print("0 to 100:", sum_all(0, 100))
print("0 to 1000", sum_all(0, 1000))
print("50 to 100:", sum_all(50, 100))
print("500 to 1000:", sum_all(500, 1000))

더보기

이 게시글은 혼공학습단(혼공파) 13기의 3주차 과제를 포함하고있습니다.

Python은 다양한 데이터를 다루기 위한 강력한 자료형을 제공합니다. 이 글에서는 리스트(List), 딕셔너리(Dictionary), 그리고 범위형(Range) 자료형의 특징과 사용법을 알아보겠습니다.

1. 리스트 (List)

리스트는 순서가 있는 값들의 모음으로, 대괄호([])로 정의됩니다. Python의 리스트는 변경 가능(mutable)하며, 다양한 자료형의 값을 함께 담을 수 있습니다.

주요 특징

• 순서가 있음: 리스트는 순서를 유지하며, 인덱스를 통해 값에 접근할 수 있습니다.
• 가변성: 값을 추가, 삭제, 수정할 수 있습니다.
• 다양한 자료형 혼합 가능: 정수, 문자열, 리스트 등 다양한 자료형을 한 리스트에 담을 수 있습니다.

리스트 생성

리스트를 생성하는 방법은 간단하며, 빈 리스트부터 초기값이 있는 리스트까지 다양하게 가능합니다.

# 빈 리스트 생성
minions = []

# 초기 값이 있는 리스트 생성
minions_names = ["Kevin", "Stuart", "Bob"]
mixed = ["Banana", 42, ["Gru", "Dr.Nefario"]]

주요 메서드와 예시

리스트의 조작 방법은 다양하며, 데이터를 효율적으로 처리할 수 있도록 도와줍니다.

# 값 추가
minions_names.append("Dave")  # ["Kevin", "Stuart", "Bob", "Dave"]

# 값 삽입
minions_names.insert(1, "Jerry")  # ["Kevin", "Jerry", "Stuart", "Bob", "Dave"]

# 값 삭제
minions_names.remove("Jerry")  # ["Kevin", "Stuart", "Bob", "Dave"]

# 정렬
minions_names.sort()  # 오름차순 정렬
minions_names.sort(reverse=True)  # 내림차순 정렬

# 리스트 컴프리헨션
uppercase_names = [name.upper() for name in minions_names]  # ["KEVIN", "STUART", "BOB", "DAVE"]

리스트 컴프리헨션은 반복문과 조건문을 활용해 간결하게 리스트를 생성할 수 있는 강력한 도구입니다. 예를 들어, 리스트의 모든 값을 대문자로 변환하는 작업을 한 줄로 처리할 수 있습니다.

2. 딕셔너리 (Dictionary)

딕셔너리는 키-값(key-value) 쌍의 모음으로, 중괄호({})를 사용하여 정의됩니다. 키를 통해 값을 빠르게 조회할 수 있는 자료형입니다.

주요 특징

• 키(Key)는 고유해야 함: 중복된 키는 허용되지 않습니다.
• 값(Value)는 중복 가능: 값에는 어떤 자료형이든 올 수 있습니다.
• 순서 유지: Python 3.7부터 삽입 순서가 유지됩니다.

딕셔너리 생성

딕셔너리는 구조화된 데이터를 저장하는 데 유용합니다. 키를 사용하여 데이터를 효율적으로 관리할 수 있습니다.

# 빈 딕셔너리 생성
minion_profile = {}

# 초기 값이 있는 딕셔너리 생성
minion_profile = {
    "name": "Kevin",
    "age": 7,
    "hobbies": ["dancing", "eating bananas"]
}

주요 메서드와 예시

딕셔너리는 키-값 쌍을 조작할 수 있는 다양한 메서드를 제공합니다.

# 값 추가 및 수정
minion_profile["city"] = "Minionville"
minion_profile["age"] = 8

# 값 삭제
minion_profile.pop("city")  # {"name": "Kevin", "age": 8, "hobbies": ["dancing", "eating bananas"]}

# 키와 값 조회
keys = minion_profile.keys()  # dict_keys(['name', 'age', 'hobbies'])
values = minion_profile.values()  # dict_values(['Kevin', 8, ['dancing', 'eating bananas']])
items = minion_profile.items()  # dict_items([('name', 'Kevin'), ('age', 8), ('hobbies', ['dancing', 'eating bananas'])])

# 딕셔너리 컴프리헨션
hobby_lengths = {key: len(value) if isinstance(value, list) else len(str(value)) for key, value in minion_profile.items()}  # {'name': 5, 'age': 1, 'hobbies': 2}

딕셔너리 컴프리헨션을 사용하면 조건에 따라 값을 동적으로 변환하거나 필터링할 수 있습니다. 위 예제에서는 각 키의 값의 길이를 계산해 새로운 딕셔너리를 생성합니다.

3. 범위형 (Range)

range는 주로 반복문에서 사용되는 자료형으로, 특정 범위의 숫자 시퀀스를 생성합니다.

주요 특징

• 순차적인 정수 생성: 시작 값부터 종료 값 직전까지 정수를 생성합니다.
• 메모리 효율성: 실제로 값을 저장하지 않고, 필요할 때 값을 생성합니다.
• 불변성: 생성된 range 객체는 변경할 수 없습니다.

범위형 생성

범위형은 반복 작업이나 간격 계산에 유용합니다.

# 기본 사용법
minion_ids = range(5)  # 0부터 4까지

# 시작과 종료값 지정
special_minion_ids = range(1, 6)  # 1부터 5까지

# 간격 지정
even_minion_ids = range(0, 10, 2)  # 0, 2, 4, 6, 8

범위형 활용

반복문과 결합하거나 특정 조건을 기반으로 범위형을 조작할 수 있습니다.

# 리스트로 변환
list_minion_ids = list(minion_ids)  # [0, 1, 2, 3, 4]

# 반복문에서 사용
for id in special_minion_ids:
    print(f"Minion ID: {id}")  # Minion ID: 1, 2, 3, 4, 5

# 필터링과 결합
filtered_ids = [id for id in even_minion_ids if id % 4 == 0]  # [0, 4, 8]

메모리 효율적인 range 객체는 리스트 변환 없이도 반복문에서 사용할 수 있습니다. 필요에 따라 리스트로 변환하거나 조건을 적용해 특정 값을 필터링할 수도 있습니다.

4. 리스트, 딕셔너리, 범위형 비교

자료형주요 특징사용 예시

결론

Python의 리스트, 딕셔너리, 그리고 범위형 자료형은 데이터를 저장하고 조작하는 데 매우 유용한 도구입니다. 각각의 자료형은 고유한 장점과 특징을 가지며, 적재적소에 활용할 수 있습니다.

이 게시글은 혼공학습단(혼공파) 13기의 2주차 과제를 포함하고있습니다.

1. if - elif 문을 활용한 구현

str_input = input("태어난 해를 입력해주세요> ")
birth_year = int(str_input)

if birth_year % 12 == 0:
    print('원숭이 띠입니다.')
elif birth_year % 12 == 1:
    print('닭 띠입니다.')
elif birth_year % 12 == 2:
    print('개 띠입니다.')
elif birth_year % 12 == 3:
    print('돼지 띠입니다.')
elif birth_year % 12 == 4:
    print('쥐 띠입니다.')
elif birth_year % 12 == 5:
    print('소 띠입니다.')
elif birth_year % 12 == 6:
    print('호랑이 띠입니다.')
elif birth_year % 12 == 7:
    print('토끼 띠입니다.')
elif birth_year % 12 == 8:
    print('용 띠입니다.')
elif birth_year % 12 == 9:
    print('뱀 띠입니다.')
elif birth_year % 12 == 10:
    print('말 띠입니다.')
elif birth_year % 12 == 11:
    print('양 띠입니다.')

설명
if-elif 구조는 조건을 순차적으로 평가하며, 첫 번째로 True가 되는 조건을 실행합니다. 조건의 흐름이 명확하여 로직을 이해하고 수정하기 쉽습니다.

장점

• 각 조건이 독립적으로 작성되어 논리적 흐름이 분명합니다.
• 조건을 추가하거나 수정하기 용이합니다.

단점

• 조건문이 많아질수록 코드가 길어지고 유지보수가 어려워질 수 있습니다.
• 조건이 많아지면 성능 면에서 비효율적일 수 있습니다.

2. 리스트를 활용한 구현

str_input = input("태어난 해를 입력해주세요> ")
birth_year = int(str_input)

animals = [
    '원숭이', '닭', '개', '돼지', 
    '쥐', '소', '범', '토끼', 
    '용', '뱀', '말', '양'
]

animal = animals[birth_year % 12]
print(f'{animal} 띠입니다.')

설명
리스트를 사용하면 태어난 해 % 12 값을 인덱스로 활용하여 동물 이름을 바로 조회할 수 있습니다. 조건문을 반복적으로 작성하지 않아도 되므로 코드가 간결하고 효율적입니다.

장점

• 코드가 간단하며, 조건을 인덱스 기반으로 처리하기 때문에 가독성이 높습니다.
• 조건과 결과가 고정된 규칙을 따를 경우 효율적으로 사용할 수 있습니다.

단점

• 연속적이지 않은 조건을 처리하기에는 적합하지 않습니다.
• 리스트 인덱스 범위를 벗어난 경우 예외가 발생할 수 있으므로 주의가 필요합니다.

3. 딕셔너리를 활용한 구현

str_input = input("태어난 해를 입력해주세요> ")
birth_year = int(str_input)

animal_dict = {
    0: '원숭이',
    1: '닭',
    2: '개',
    3: '돼지',
    4: '쥐',
    5: '소',
    6: '범',
    7: '토끼',
    8: '용',
    9: '뱀',
    10: '말',
    11: '양'
}

animal = animal_dict[birth_year % 12]
print(f'{animal} 띠입니다.')

설명
딕셔너리는 키-값 쌍으로 구성된 자료구조로, 특정 키에 해당하는 값을 빠르게 검색할 수 있습니다. 조건과 결과가 명확히 매핑되어야 하는 경우 딕셔너리를 사용하면 효율적입니다.

장점

• 조건과 결과를 명확히 매핑할 수 있어 가독성이 뛰어납니다.
• 특정 키를 빠르게 검색할 수 있어 성능이 우수합니다.

단점

• 데이터 초기화가 필요하며, 조건이 동적이거나 복잡한 경우에는 적합하지 않을 수 있습니다.

4. 세 가지 방식 비교

5. 어떤 방법을 선택할까?

• if-elif: 조건이 적고 논리적인 흐름을 순차적으로 표현해야 하는 경우.
• 리스트: 조건이 숫자 인덱스를 기반으로 규칙적이고 간단한 경우.
• 딕셔너리: 조건과 결과가 명확히 매핑되는 경우. 특히 대량의 데이터 검색이 필요한 경우.

이 게시글은 혼공학습단(혼공파) 13기의 1주차 과제를 포함하고있습니다.

1. print() 함수의 기본 사용법

print() 함수는 값을 출력하기 위해 사용됩니다.

print("안녕하세요, Python!") # 출력: 안녕하세요, Python!

print("이름:", "성호", "나이:", 25) # 출력: 이름: 성호 나이: 25

2. print() 함수의 파라미터

help(print)

Help on built-in function print in module builtins:

print(*args, sep=' ', end='\n', file=None, flush=False)
    Prints the values to a stream, or to sys.stdout by default.

    sep
      string inserted between values, default a space.
    end
      string appended after the last value, default a newline.
    file
      a file-like object (stream); defaults to the current sys.stdout.
    flush
      whether to forcibly flush the stream.

• print() 함수는 하나 이상의 값을 출력할 수 있는 Python의 내장 함수입니다.
• *args: 여러 개의 값을 가변 위치 인수 형태로 받을 수 있습니다. 예를 들어, print(1, 2, 3)처럼 쉼표로 구분된 값들을 전달할 수 있습니다.

1) sep (구분자)

• 설명: 출력할 여러 값 사이에 삽입할 문자열을 지정합니다.
• 기본값: 공백 (' ')

print("Python", "is", "awesome", sep="-") # 출력: Python-is-awesome

2) end (끝 문자열)

• 설명: 출력이 끝난 후 추가로 삽입할 문자열을 지정합니다.
• 기본값: 줄바꿈 ('\n')

print("Hello", end=" ") print("World") # 출력: Hello World

3) file

• 설명: 출력 대상을 지정합니다. 기본적으로 표준 출력(sys.stdout, 일반적으로 콘솔)에 출력되지만, 파일 객체를 전달하여 출력 내용을 파일에 저장할 수도 있습니다.
• 기본값: sys.stdout

with open("output.txt", "w") as f:
    print("파일에 출력됩니다.", file=f)
# 파일에 "파일에 출력됩니다."라는 텍스트가 저장됩니다.

4) flush

• 설명: 출력 내용을 즉시 스트림에 강제로 내보낼지 여부를 결정합니다.
• 기본값: False (스트림이 자동으로 관리)

import time

for i in range(5):
    print(i, end=" ", flush=True)
    time.sleep(1)
# 출력: 0 1 2 3 4 (1초 간격으로 출력)

3. 여러 줄 출력

print() 함수는 이스케이프 문자를 사용해 여러 줄을 출력할 수 있습니다.

print("안녕하세요,\nPython입니다.")
# 출력:
# 안녕하세요,
# Python입니다.

또는 삼중 따옴표(""")를 활용하여 더 깔끔하게 작성할 수도 있습니다.

print("""
안녕하세요,
Python입니다.
""")
# 출력:
# 
# 안녕하세요,
# Python입니다.
#

삼중따옴표(""")에 '\' 기호를 추가("""\)하면 의도하지 않은 공백을 방지할 수 있습니다

print("""\
안녕하세요,
Python입니다.
""")
# 출력:
# 안녕하세요,
# Python입니다.

4. f-string과 함께 사용하기

Python 3.6부터 도입된 f-string을 사용하면 문자열 포매팅이 훨씬 직관적입니다.

name = "성호"
age = 25
print(f"이름: {name}, 나이: {age}")
# 출력: 이름: 성호, 나이: 25

f-string은 수식도 지원합니다.

a, b = 5, 3
print(f"{a} + {b} = {a + b}")
# 출력: 5 + 3 = 8

5. print()를 활용한 디버깅

print()는 디버깅에도 자주 사용됩니다. 특히, 변수 값을 확인하거나 실행 흐름을 추적할 때 유용합니다.

def calculate(x, y):
    print(f"x: {x}, y: {y}")  # 디버깅용 출력
    return x + y

result = calculate(5, 10)
print(f"결과: {result}")
# 출력:
# x: 5, y: 10
# 결과: 15

마무리

print() 함수는 단순히 값을 출력하는 데 그치지 않고, 다양한 매개변수를 통해 커스터마이징된 출력이 가능합니다. 또한 디버깅, 파일 출력, 실시간 로깅 등 다양한 상황에서 유용하게 사용됩니다.

여기서부터는 혼공파의 1주차 과제 입니다.

1. 프로그램의 실행 결과를 예측해보세요.

print("# 연습문제")
print("\\\\\\\\")
print("-" * 8)

# 연습문제
\\\\
--------

2. 다음 프로그램을 실행결과를 예측해보세요. 오류가 발생하면 왜 발생하는지 작성해보세요.

print("안녕하세요"[1])
print("안녕하세요"[2])
print("안녕하세요"[3])
print("안녕하세요"[4])
print("안녕하세요"[5])

더보기

녕
하
세
요
IndexError: string index out of range

•  "안녕하세요"[1]:
  • 문자열 "안녕하세요"에서 인덱스는 0부터 시작합니다.
  • 인덱스 1은 "녕"에 해당합니다.
• "안녕하세요"[2]와 "안녕하세요"[3] 및 "안녕하세요"[4]는 각각 "하", "세", "요"에 해당합니다.
• "안녕하세요"[5]:
  • 문자열 "안녕하세요"의 길이는 5이지만, 유효한 인덱스는 0 ~ 4입니다.
  • 인덱스 5는 문자열 범위를 벗어나므로 IndexError가 발생합니다.

 

3. 다음 프로그램의 실행결과를 예측해보세요

print("안녕하세요"[1:3])
print("안녕하세요"[2:4])
print("안녕하세요"[1:])
print("안녕하세요"[:3])

녕하
하세요
녕하세요
안녕하

Linux 시스템을 운영할 때, Swap Memory라는 용어를 처음 들었습니다. Swap 메모리는 물리적 메모리(RAM)가 부족할 때 시스템이 디스크 공간을 활용하여 메모리를 대체하는 방식입니다. 이 글에서는 Swap 메모리의 개념과 활용 방법, 그리고 설정 방법에 대해 알아보겠습니다.

AWS EC2 t2.micro에서의 Swap Memory 경험

AWS EC2의 t2.micro(1GB RAM) 인스턴스를 사용하면서 프로젝트 빌드 실패 문제를 겪었습니다. CloudWatch를 이용해 확인해 보니 CPU 사용률이 99%로 유지되었고, 메모리 사용량이 문제일 가능성이 있다는 것을 알게 되었습니다. 이 과정에서 Swap 메모리를 처음 알게 되었고, 이를 적용한 결과 문제를 성공적으로 해결할 수 있었습니다.

Swap Memory란?

Swap Memory는 물리적 메모리(RAM)가 부족할 때, 운영체제가 디스크의 특정 공간을 임시 메모리로 사용하는 기술입니다. 이는 시스템이 메모리를 효율적으로 사용하도록 돕고, 과도한 메모리 사용으로 인해 발생할 수 있는 시스템 충돌을 방지합니다.

주요 특징

1. RAM보다 속도가 느림: Swap 메모리는 디스크를 사용하므로 RAM에 비해 데이터 읽기/쓰기 속도가 훨씬 느립니다.
2. 메모리 부족 시 사용됨: 시스템에서 RAM이 가득 차면 Swap 영역을 사용하기 시작합니다.
3. 디스크 I/O에 의존: Swap 사용 시 디스크 입출력이 발생하므로 디스크 성능이 중요한 역할을 합니다.
4. 유연한 메모리 관리: 시스템이 메모리 부족 상태에서도 프로그램을 종료하지 않고 실행 상태를 유지할 수 있습니다.

Swap Memory의 장점

• 시스템 안정성 보장: 메모리가 부족한 상황에서 프로세스를 강제로 종료하지 않고 계속 실행할 수 있도록 도와줍니다.
• 저비용 확장 가능성: 추가 RAM을 구매하지 않고도 디스크 공간만으로 메모리 부족 문제를 완화할 수 있습니다.

Swap Memory의 단점

• 성능 저하: RAM보다 속도가 느리기 때문에 Swap 메모리를 과도하게 사용할 경우 시스템 성능이 크게 저하될 수 있습니다.
• 디스크 의존성: 디스크 수명에 영향을 미칠 수 있으며, 특히 SSD를 사용하는 경우 주의가 필요합니다. SSD는 쓰기 작업의 수명이 제한되어 있어 Swap 사용이 디스크의 수명을 단축시킬 수 있습니다.

Swap Memory의 필요성

1. 메모리 부족 상황 대응

물리적 메모리가 부족한 경우, Swap 메모리는 프로그램이 계속 실행되도록 지원합니다. 이는 서버나 워크스테이션에서 특히 유용합니다. 예를 들어, 여러 사용자가 동시에 작업하거나 대규모 데이터를 처리하는 환경에서 RAM이 부족할 수 있습니다.

사례: AWS EC2 t2.micro 환경에서 Swap 활용

사용자가 무료로 제공되는 AWS EC2 t2.micro 인스턴스(1GB RAM)를 사용하는 경우, 제한된 메모리로 인해 메모리 부족 상황이 자주 발생할 수 있습니다. Swap Memory를 설정하면 이러한 환경에서도 안정적으로 애플리케이션을 실행할 수 있습니다.

2. 시스템 안정성 향상

Swap 메모리는 RAM의 과부하로 인해 발생할 수 있는 시스템 충돌을 방지하여 안정성을 향상시킵니다. 메모리 부족으로 인해 발생할 수 있는 "Out of Memory"(OOM) 에러를 방지하는 데 중요한 역할을 합니다.

3. 일시적 과부하 처리

특정 시점에 메모리 사용량이 급증하는 경우 Swap 메모리는 RAM을 보완하며, 시스템이 원활히 작동할 수 있도록 지원합니다. 이는 메모리 사용량이 일정하지 않은 애플리케이션에 유용합니다.

Swap Memory가 불필요한 경우

• 충분한 물리적 메모리가 설치된 시스템에서는 Swap 메모리의 필요성이 낮아질 수 있습니다.
• 고성능을 요구하는 작업(예: 데이터베이스 처리)에서는 Swap 사용이 성능에 부정적 영향을 줄 수 있습니다.

Swap Memory의 설정

1. Swap 확인하기

현재 시스템에서 Swap 메모리가 설정되어 있는지 확인하려면 다음 명령어를 사용합니다.

sudo swapon --show

만약 Swap 메모리가 설정되어 있지 않다면, 아무것도 출력되지 않습니다.

2. Swap 파일 생성하기

다음은 Swap 파일을 생성하고 활성화하는 과정입니다. (위 명령어는 2GB 크기의 Swap 파일을 생성합니다.)

sudo fallocate -l 2G /swapfile

3. Swap 파일 권한 설정

sudo chmod 600 /swapfile

4. Swap 영역 초기화

sudo mkswap /swapfile

5 . Swap 활성화

sudo swapon /swapfile

6. 부팅 시 Swap 자동 활성화

echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab

Swap 메모리 사용 모니터링

Swap 메모리 사용량은 다음 명령어로 모니터링할 수 있습니다.

free -h

또는 더 자세한 정보를 얻으려면.

vmstat

결론

스왑 메모리는 물리적 메모리가 부족한 상황에서 시스템 안정성을 유지하고 성능 저하를 완화할 수 있는 유용한 도구입니다. 특히 AWS의 EC2 t2.micro(Free tier)같은 제한된 리소스 환경에서 스왑 메모리를 활용하면 비용 효율적으로 문제를 해결할 수 있습니다.

하지만 이는 어디까지나 임시방편적인 해결책입니다. 스왑 메모리는 SSD나 하드 디스크의 공간을 사용하기 때문에 RAM에 비해 접근 속도가 느리며, 과도한 사용은 시스템 성능의 심각한 저하를 초래할 수 있습니다.

장기적인 관점에서는 물리적 메모리 증설이나 애플리케이션의 메모리 사용 최적화와 같은 근본적인 해결책을 고려해야 합니다.

스왑 메모리는 긴급한 상황에서의 임시 해결책으로 활용하되, 시스템의 안정적인 운영을 위해서는 적절한 하드웨어 리소스 확보가 필수적입니다