인터럽트 (Interrupt)

핵심 인사이트 (3줄 요약)

CPU가 외부/내부 이벤트에 비동기적으로 응답하여 현재 작업을 중단하고 긴급 처리를 수행하는 메커니즘. 폴링(Polling) 대비 CPU 활용 효율이 높으며, 입출력, 예외, 타이머, 시스템 콜 등을 처리한다. 인터럽트 벡터, ISR(Interrupt Service Routine), 우선순위 관리가 핵심 구성 요소다.

Ⅰ. 개요 (필수: 200자 이상)

개념: 인터럽트(Interrupt)는 CPU가 정상적인 프로그램 실행 중에 외부 장치나 내부 이벤트의 요청에 의해 현재 작업을 일시 중단하고, 해당 이벤트를 처리하기 위한 특정 루틴(ISR)을 실행한 후 다시 원래 작업으로 복귀하는 메커니즘이다.

💡 비유: 인터럽트는 **"수업 중 비상벨"**과 같다. 선생님(CPU)이 수업(프로그램)을 진행하다가 비상벨(인터럽트 신호)이 울리면, 수업을 잠시 멈추고 대피(ISR 실행)를 지시한다. 대피가 끝나면 다시 수업을 이어간다. 이때 어디까지 했는지(PC, 레지스터)는 칠판에 적어둔다.

등장 배경 (필수: 3가지 이상 기술):

기존 문제점 - 폴링(Polling)의 비효율: 폴링은 CPU가 주기적으로 "입력 있어?"라고 외부 장치를 확인해야 한다. 입력이 없을 때도 확인하는 과정에서 CPU 사이클을 낭비하며, 입력 발생 즉시 응답할 수 없다.
기술적 필요성: I/O 장치(키보드, 마우스, 디스크, 네트워크)는 CPU보다 훨씬 느리다. CPU가 I/O 완료를 기다리며 대기하면 비효율적이므로, I/O 완료 시 CPU에 알림을 보내는 방식이 필요했다.
시장/산업 요구: 실시간 시스템(원자력 제어, 항공우주, 산업 자동화)에서는 즉각적인 이벤트 응답이 필수적이다. 예외 상황(0으로 나누기, 메모리 오류)에도 안전하게 대응해야 한다.

핵심 목적: CPU가 I/O 대기 시간을 최소화하고, 외부 이벤트에 즉시 응답하여 시스템 효율성과 실시간성을 보장하는 것이다.

Ⅱ. 구성 요소 및 핵심 원리 (필수: 가장 상세하게)

구성 요소 (필수: 최소 4개 이상):

구성 요소	역할/기능	특징	비유
IRQ (Interrupt Request)	인터럽트 요청 신호	하드웨어 핀 또는 소프트웨어 트랩	비상벨 버튼
인터럽트 벡터 테이블	ISR 주소를 저장한 테이블	메모리 고정 위치, 각 인터럽트별 4Byte	비상 대피로 안내도
ISR (Interrupt Service Routine)	인터럽트 처리 함수	짧고 빠르게 작성, 컨텍스트 저장/복원	대피 훈련 매뉴얼
PIC/APIC	인터럽트 컨트롤러	우선순위 관리, 인터럽트 라우팅	안내 방송실
PSW (Program Status Word)	CPU 상태 플래그	인터럽트 가능/불가 비트 포함	수업 진행 상황판
스택 (Stack)	컨텍스트 저장 영역	PC, 레지스터, 플래그 저장	칠판에 적은 내용

구조 다이어그램 (필수: ASCII 아트):

┌─────────────────────────────────────────────────────────────────────────────┐
│                         인터럽트 처리 구조                                   │
├─────────────────────────────────────────────────────────────────────────────┤
│                                                                             │
│   ┌──────────────────────────────────────────────────────────────────┐     │
│   │                     하드웨어 인터럽트 소스                        │     │
│   │  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐    │     │
│   │  │ 타이머  │ │ 키보드  │ │  디스크  │ │ 네트워크│ │  UART   │    │     │
│   │  │  IRQ0   │ │  IRQ1   │ │  IRQ14  │ │  IRQ19  │ │  IRQ3   │    │     │
│   │  └────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘ └────┬────┘    │     │
│   └───────┼──────────┼──────────┼──────────┼──────────┼─────────────┘     │
│           │          │          │          │          │                    │
│           └──────────┴──────────┼──────────┴──────────┘                    │
│                                 ↓                                          │
│   ┌──────────────────────────────────────────────────────────────────┐    │
│   │              PIC/APIC (인터럽트 컨트롤러)                         │    │
│   │  ┌─────────────────────────────────────────────────────────────┐ │    │
│   │  │  • 우선순위 판별 (IRQ0 > IRQ1 > ...)                       │ │    │
│   │  │  • 인터럽트 마스킹 (특정 IRQ 차단 가능)                    │ │    │
│   │  │  • CPU로 인터럽트 신호 전달 (INT)                          │ │    │
│   │  │  • 벡터 번호 제공                                         │ │    │
│   │  └─────────────────────────────────────────────────────────────┘ │    │
│   └──────────────────────────────────────────────────────────────────┘    │
│                                 ↓ INT + Vector                             │
│   ┌──────────────────────────────────────────────────────────────────┐    │
│   │                          CPU                                     │    │
│   │  ┌─────────────────────────────────────────────────────────────┐ │    │
│   │  │  1. 현재 명령어 완료                                        │ │    │
│   │  │  2. PC, PSW, 레지스터 → 스택 저장 (Context Save)            │ │    │
│   │  │  3. 인터럽트 비활성화 (IF=0)                                │ │    │
│   │  │  4. 벡터 × 4 → ISR 주소 계산                               │ │    │
│   │  │  5. PC = ISR 주소 (ISR 실행)                               │ │    │
│   │  └─────────────────────────────────────────────────────────────┘ │    │
│   └──────────────────────────────────────────────────────────────────┘    │
│                                 ↓                                          │
│   ┌──────────────────────────────────────────────────────────────────┐    │
│   │              인터럽트 벡터 테이블 (IVT)                          │    │
│   │  ┌─────────────────────────────────────────────────────────────┐ │    │
│   │  │  번호   │   ISR 주소   │         설명                      │ │    │
│   │  ├─────────────────────────────────────────────────────────────┤ │    │
│   │  │   0     │  0x0000      │  리셋 (Reset)                     │ │    │
│   │  │   1     │  0x0004      │  NMI (Non-Maskable Interrupt)    │ │    │
│   │  │   2     │  0x0008      │  Hard Fault                       │ │    │
│   │  │   3     │  0x000C      │  Memory Management Fault          │ │    │
│   │  │   ...   │  ...         │  ...                              │ │    │
│   │  │  32~255 │  사용자 정의 │  외부 인터럽트/소프트웨어 인터럽트│ │    │
│   │  └─────────────────────────────────────────────────────────────┘ │    │
│   └──────────────────────────────────────────────────────────────────┘    │
│                                 ↓                                          │
│   ┌──────────────────────────────────────────────────────────────────┐    │
│   │              ISR (Interrupt Service Routine)                     │    │
│   │  ┌─────────────────────────────────────────────────────────────┐ │    │
│   │  │  ISR_Handler:                                               │ │    │
│   │  │      PUSH {R0-R3, R12, LR}    ; 레지스터 저장              │ │    │
│   │  │      ; --- 인터럽트 처리 로직 ---                          │ │    │
│   │  │      BL  Process_Interrupt                                  │ │    │
│   │  │      ; --- 처리 완료 ---                                   │ │    │
│   │  │      POP  {R0-R3, R12, LR}   ; 레지스터 복원               │ │    │
│   │  │      IRET                     ; 인터럽트 복귀              │ │    │
│   │  └─────────────────────────────────────────────────────────────┘ │    │
│   └──────────────────────────────────────────────────────────────────┘    │
└─────────────────────────────────────────────────────────────────────────────┘

동작 원리 (필수: 단계별 상세 설명):

① IRQ 발생 → ② 우선순위 판별 → ③ 현재 작업 저장 → ④ ISR 주소 획득 → ⑤ ISR 실행 → ⑥ 복귀

1단계 - IRQ(Interrupt Request) 발생:
- 하드웨어: 외부 장치가 IRQ 라인에 신호
- 소프트웨어: INT n 명령어 실행 (시스템 콜)
- 예외: 0 나누기, 페이지 폴트, 잘못된 명령어
- PIC/APIC가 인터럽트 신호를 CPU로 전달
2단계 - 우선순위 판별 및 마스킹 확인:
- PIC가 여러 인터럽트 중 가장 높은 우선순위 선택
- IF(Interrupt Flag)가 1인지 확인 (CLI로 비활성화 가능)
- NMI(Non-Maskable Interrupt)는 IF 무시하고 처리
- 현재 실행 중인 인터럽트보다 낮은 우선순위면 대기
3단계 - 컨텍스트 저장 (Context Save):
- 현재 명령어 완료까지 대기
- PC(Program Counter)를 스택에 저장
- PSW(Program Status Word)를 스택에 저장
- 범용 레지스터는 ISR에서 수동 저장
4단계 - ISR 주소 획득:
- PIC로부터 벡터 번호(Vector Number) 수신
- 벡터 × 4(또는 8)로 IVT 내 주소 계산
- IVT에서 ISR 시작 주소 로드
- PC = ISR 주소로 설정
5단계 - ISR 실행:
- ISR 진입, 추가 레지스터 저장
- 인터럽트 원인 확인(IIR, Interrupt Identification Register)
- 실제 처리 수행 (데이터 읽기, 플래그 설정 등)
- 인터럽트 컨트롤러에 EOI(End Of Interrupt) 전송
- 저장된 레지스터 복원
6단계 - 원래 작업 복귀:
- IRET/RTI 명령어 실행
- 스택에서 PC, PSW 복원
- 인터럽트 전 실행 중이던 명령어 다음부터 재개

핵심 알고리즘/공식 (해당 시 필수):

인터럽트 지연 시간 (Interrupt Latency):
┌─────────────────────────────────────────────────────────────────┐
│  Latency = t_hw + t_sw + t_isr_entry                           │
│                                                                 │
│  t_hw: 하드웨어 신호 전달 시간 (수 ns)                          │
│  t_sw: 현재 명령어 완료 대기 시간 (1~수십 cycles)               │
│  t_isr_entry: 컨텍스트 저장 시간 (10~50 cycles)                 │
├─────────────────────────────────────────────────────────────────┤
│  실시간 시스템 요구사항:                                        │
│  • Hard Real-time: Latency < 10μs (보장)                       │
│  • Soft Real-time: Latency < 100μs (평균)                      │
│  • 일반 OS: Latency < 1ms                                       │
└─────────────────────────────────────────────────────────────────┘

인터럽트 처리 시간:
ISR_Time = Context_Save + Process + Context_Restore + IRET
         = 10~50 cycles + 처리시간 + 10~50 cycles + 5~10 cycles

ISR 작성 원칙:
• 가능한 짧게 (수십 μs 이내)
• 블로킹 함수 호출 금지 (sleep, mutex, I/O)
• 다른 인터럽트 차단 최소화

코드 예시 (필수: Python 또는 의사코드):

# 인터럽트 시스템 시뮬레이터
class InterruptSystem:
    def __init__(self):
        # 인터럽트 벡터 테이블 (256개)
        self.ivt = [None] * 256

        # CPU 상태
        self.pc = 0
        self.registers = [0] * 16
        self.psw = {'IF': True, 'ZF': False, 'NF': False}
        self.stack = []

        # 인터럽트 큐 (우선순위 큐)
        self.pending_interrupts = []

        # 프로그램 메모리
        self.program = []
        self.running = True

        # 통계
        self.interrupt_count = 0

    def register_isr(self, vector, handler):
        """ISR 등록"""
        self.ivt[vector] = handler

    def request_interrupt(self, vector, priority=0):
        """인터럽트 요청"""
        self.pending_interrupts.append((priority, vector))
        self.pending_interrupts.sort(reverse=True)  # 우선순위 높은 순

    def check_interrupts(self):
        """인터럽트 확인 및 처리"""
        if not self.psw['IF']:  # 인터럽트 비활성화
            return False

        if not self.pending_interrupts:
            return False

        # 가장 높은 우선순위 인터럽트 처리
        priority, vector = self.pending_interrupts.pop(0)
        self._handle_interrupt(vector)
        return True

    def _handle_interrupt(self, vector):
        """인터럽트 처리"""
        self.interrupt_count += 1

        # 1. 컨텍스트 저장
        self._save_context()

        # 2. 인터럽트 비활성화
        self.psw['IF'] = False

        # 3. ISR 실행
        isr = self.ivt[vector]
        if isr:
            isr(self)  # ISR 호출
        else:
            print(f"Unknown interrupt: vector={vector}")

        # 4. 컨텍스트 복원
        self._restore_context()

        # 5. 인터럽트 활성화
        self.psw['IF'] = True

    def _save_context(self):
        """컨텍스트 저장"""
        self.stack.append({
            'pc': self.pc,
            'registers': self.registers.copy(),
            'psw': self.psw.copy()
        })

    def _restore_context(self):
        """컨텍스트 복원"""
        if self.stack:
            context = self.stack.pop()
            self.pc = context['pc']
            self.registers = context['registers']
            # PSW의 IF는 마지막에 복원

    def run(self, max_cycles=1000):
        """CPU 실행 루프"""
        for cycle in range(max_cycles):
            # 인터럽트 확인
            if self.check_interrupts():
                continue  # ISR 실행 후 계속

            # 명령어 실행
            if self.pc < len(self.program):
                instr = self.program[self.pc]
                self._execute(instr)
                self.pc += 1
            else:
                break

    def _execute(self, instr):
        """명령어 실행 (간소화)"""
        pass


# ISR 예시들
def timer_isr(cpu):
    """타이머 인터럽트 핸들러"""
    print(f"[TIMER ISR] Tick at PC={cpu.pc}")
    # 타이머 카운터 증가, 스케줄링 등

def keyboard_isr(cpu):
    """키보드 인터럽트 핸들러"""
    print(f"[KEYBOARD ISR] Key pressed")
    # 키보드 버퍼 읽기, 이벤트 큐에 추가

def divide_by_zero_isr(cpu):
    """0으로 나누기 예외 핸들러"""
    print(f"[EXCEPTION] Divide by zero at PC={cpu.pc}")
    cpu.pc += 1  # 다음 명령어로 건너뜀


# 사용 예시
cpu = InterruptSystem()

# ISR 등록
cpu.register_isr(32, timer_isr)       # IRQ0: 타이머
cpu.register_isr(33, keyboard_isr)    # IRQ1: 키보드
cpu.register_isr(0, divide_by_zero_isr)  # Exception: 0 나누기

# 프로그램 로드
cpu.program = ['NOP', 'NOP', 'NOP', 'NOP', 'HALT']

# 인터럽트 발생 시뮬레이션
import threading
import time

def interrupt_generator():
    time.sleep(0.001)  # 1ms 후 타이머 인터럽트
    cpu.request_interrupt(32, priority=1)
    time.sleep(0.001)  # 1ms 후 키보드 인터럽트
    cpu.request_interrupt(33, priority=2)  # 높은 우선순위

thread = threading.Thread(target=interrupt_generator)
thread.start()

cpu.run()
print(f"총 인터럽트 처리: {cpu.interrupt_count}회")

Ⅲ. 기술 비교 분석 (필수: 2개 이상의 표)

장단점 분석 (필수: 최소 3개씩):

장점	단점
CPU 효율성: I/O 대기 없이 다른 작업 수행	오버헤드: 컨텍스트 저장/복원 비용
실시간 응답: 이벤트 발생 즉시 처리	설계 복잡도: 우선순위, 동기화 관리
저전력: 대기 모드에서 이벤트 시 깨어남	디버깅 어려움: 비결정적 실행
확장성: 다양한 장치 통합 가능	스택 오버플로우: 중첩 인터럽트 시

인터럽트 vs 폴링 비교 (필수: 최소 2개 대안):

비교 항목	인터럽트 (Interrupt)	폴링 (Polling)
동작 방식	이벤트 발생 시 CPU에 알림	CPU가 주기적으로 상태 확인
CPU 활용률	★ 높음 (이벤트 시에만 처리)	낮음 (빈번한 확인 필요)
응답 시간	★ 빠름 (즉시)	느림 (폴링 주기 의존)
하드웨어 복잡도	높음 (인터럽트 컨트롤러 필요)	★ 낮음 (단순)
전력 소비	★ 낮음 (대기 가능)	높음 (지속적 폴링)
실시간성	★ 보장 가능	보장 어려움
적합한 상황	실시간, 저전력, 다중 장치	단순 시스템, 고속 장치

★ 선택 기준: 대부분의 시스템에서 인터럽트가 우선. 폴링은 매우 단순한 시스템이나, 장치가 항상 준비된 상태(예: SSD 내부 컨트롤러)에서만 사용.

인터럽트 종류 비교:

종류	원인	우선순위	마스킹	예시
Reset	전원 ON, 리셋 버튼	최고	불가	시스템 시작
NMI	하드웨어 오류	매우 높음	불가	메모리 패리티 오류, 정전
Hard Fault	CPU 예외	높음	불가	0 나누기, 잘못된 명령어
External IRQ	외부 장치	중간~낮음	가능	키보드, 타이머, 디스크
Software Interrupt	INT 명령어	낮음	가능	시스템 콜, 디버거
Page Fault	메모리 접근 오류	중간	부분 가능	가상 메모리

Ⅳ. 실무 적용 방안 (필수: 기술사 판단력 증명)

기술사적 판단 (필수: 3개 이상 시나리오):

적용 분야	구체적 적용 방법	기대 효과 (정량)
RTOS 설계	우선순위 기반 선점형 스케줄링, 인터럽트 지연 10μs 이하 보장	실시간성 99.99% 달성
임베디드 시스템	모든 I/O를 인터럽트로 처리, 저전력 모드 활용	CPU 활용률 80% 향상, 전력 50% 절감
OS 커널	시스템 콜에 소프트웨어 인터럽트 활용, 페이지 폴트 핸들링	사용자-커널 전환 1μs 이하
드라이버 개발	ISR + Tasklet/Workqueue 2단계 처리, ISR은 최소화	인터럽트 처리 100μs 이내

실제 도입 사례 (필수: 구체적 기업/서비스):

사례 1: 자동차 ECU (Electronic Control Unit) - 엔진 제어, 브레이크 시스템에서 CAN 버스 인터럽트로 1ms 이내 응답. 우선순위: 브레이크 > 엔진 > 편의기능.
사례 2: 스마트폰 터치스크린 - 터치 인터럽트 발생 시 CPU를 Sleep에서 깨움. 120Hz 디스플레이에서 8.3ms 내 터치 응답.
사례 3: 네트워크 카드 (NIC) - 패킷 수신 시 DMA로 버퍼에 저장 후 인터럽트 발생. NAPI(New API)로 인터럽트 폭주 방지.

도입 시 고려사항 (필수: 4가지 관점):

기술적:
- 인터럽트 지연 시간(Latency) 요구사항 파악
- 우선순위 체계 설계 (최대 256개까지 가능)
- 중첩 인터럽트 허용 여부 결정
- ISR 최소화 원칙 (Top-half/Bottom-half 분리)
운영적:
- 인터럽트 통계 모니터링 (발생 빈도, 처리 시간)
- 인터럽트 스톰(Storm) 대응 방안
- ISR 디버깅 방법 (JTAG, 로그)
- IRQ 공유(Sharing) 관리
보안적:
- 인터럽트 기반 공격 (IRQ Storm DoS)
- 커널 모드 전환 시 권한 검증
- 신뢰할 수 없는 장치의 IRQ 차단
- Side-channel 타이밍 공격 방지
경제적:
- 인터럽트 컨트롤러 비용 (PIC vs APIC vs GIC)
- 개발 복잡도 증가 → 개발 비용
- 실시간성 요구사항에 따른 하드웨어 선택
- 유지보수 비용 (ISR 버그 수정)

주의사항 / 흔한 실수 (필수: 최소 3개):

❌ ISR에서 블로킹 호출: ISR 내에서 sleep, mutex, 긴 I/O 수행 → 시스템 멈춤
❌ ISR 너무 길게 작성: 다른 인터럽트 차단 시간 증가 → 실시간성 저하
❌ 인터럽트 폭주 무대책: 고속 네트워크에서 패킷마다 인터럽트 → CPU 100% → NAPI 사용

관련 개념 / 확장 학습 (필수: 최소 5개 이상 나열):

📌 인터럽트 핵심 연관 개념 맵

┌─────────────────────────────────────────────────────────────────┐
│                        인터럽트                                  │
├─────────────────────────────────────────────────────────────────┤
│                                                                 │
│  폴링 ←──→ 인터럽트 ←──→ 예외처리                               │
│     ↓          ↓            ↓                                   │
│  I/O제어    컨텍스트     시스템콜                                │
│     ↓          ↓            ↓                                   │
│  DMA       스케줄링      트랩                                    │
│                                                                 │
└─────────────────────────────────────────────────────────────────┘

관련 개념	관계	설명	문서 링크
폴링 (Polling)	대안 기법	CPU가 주기적으로 장치 상태 확인	`[폴링](./polling.md)`
예외 처리 (Exception)	유사 개념	프로그램 오류 시 CPU 자동 인터럽트	`[예외 처리](./exception.md)`
컨텍스트 스위칭	핵심 메커니즘	인터럽트 시 레지스터 저장/복원	`[컨텍스트 스위칭](./context_switch.md)`
DMA	I/O 최적화	인터럽트 없이 데이터 전송	`[DMA](./dma.md)`
시스템 콜	소프트웨어 인터럽트	사용자→커널 모드 전환	`[시스템 콜](./system_call.md)`
CPU 스케줄링	연계 동작	타이머 인터럽트로 프로세스 전환	`[CPU 스케줄링](../02_operating_system/cpu_scheduling.md)`

Ⅴ. 기대 효과 및 결론 (필수: 미래 전망 포함)

정량적 기대 효과 (필수):

효과 영역	구체적 내용	정량적 목표
CPU 효율	I/O 대기 시간 활용	CPU 활용률 80% 이상
응답성	이벤트 즉시 처리	인터럽트 지연 10μs 이하
전력	대기 모드 활용	대기 전력 90% 절감
실시간성	결정적 응답 보장	데드라인 미스 0회

미래 전망 (필수: 3가지 관점):

기술 발전 방향:
- MSI-X (Message Signaled Interrupts): PCI Express용 메시지 기반 인터럽트
- 가상화 인터럽트: VM 간 인터럽트 전달 최적화 (APICv, AVIC)
- 이벤트 기반 아키텍처: 서버리스, Edge Trigger 인터럽트 확대
시장 트렌드:
- 실시간 OS(RTOS) 수요 증가 (자율주행, 산업용 IoT)
- 저전력 인터럽트 설계 (배터리 기기)
- 인터럽트 보안 강화 (Side-channel 방지)
후속 기술:
- Hardware Event Routing: 인터럽트를 특정 코어로 직접 라우팅
- Interrupt Coalescing: 여러 인터럽트를 묶어서 처리
- AI 기반 인터럽트 예측: 인터럽트 발생 패턴 학습

결론: 인터럽트는 현대 컴퓨터 시스템의 이벤트 기반 처리의 핵심 메커니즘으로, CPU 효율성과 실시간성을 동시에 확보한다. RTOS, 임베디드, 서버 가상화 등 다양한 분야에서 인터럽트 설계가 시스템 성능을 결정한다.

※ 참고 표준: ARM Architecture Reference Manual (Exception Model), Intel 64 SDM Vol. 3 (Interrupt Handling), PIC/APIC Specification, POSIX.1 (Real-time Signals)

어린이를 위한 종합 설명 (필수)

인터럽트는 "수업 중 비상벨"이야!

학교에서 수업을 하고 있는데 갑자기 비상벨이 울리면 어떻게 될까요? 선생님(CPU)은 수업(프로그램)을 멈추고 학생들을 밖으로 대피시켜요. 대피가 끝나면 다시 교실로 돌아와서 수업을 계속해요.

인터럽트가 없다면 어떨까요?

선생님이 매번 "불난 거 없나?" "지진 난 거 없나?" 계속 확인해야 해요. 이게 **폴링(Polling)**이에요. 너무 힘들고 비효율적이죠! 😓

인터럽트는 비상벨처럼 문제가 생기면 알아서 선생님에게 알려줘요. 그래서 선생님은 수업에만 집중할 수 있어요! 📚

인터럽트 처리 과정:

수업 중 → 선생님이 수업 진행 중
땡땡땡! → 비상벨(인터럽트 신호) 울림
잠깐 멈춤 → 칠판에 "30쪽까지 했음" 적어둠 (컨텍스트 저장)
대피! → 학생들 밖으로 이동 (ISR 실행)
돌아오기 → 칠판 내용 확인하고 31쪽부터 계속 (복귀)

인터럽트에도 순서가 있어요:

🔥 화재 경보 (최우선): 무조건 먼저 대피!
🚨 지진 경보 (높음): 화재 다음으로 중요
🔔 종소리 (보통): 쉬는 시간 알림
📢 방송 (낮음): 점심 메뉴 안내

이렇게 중요한 것부터 먼저 처리해요!

컴퓨터에서의 인터럽트:

⌨️ 키보드 입력: "A 키 눌렀어!"
🖱️ 마우스 클릭: "여기 클릭했어!"
⏰ 타이머: "1초 지났어!"
💾 디스크: "데이터 읽기 끝났어!"

인터럽트 덕분에 컴퓨터는 우리 입력을 즉시 처리할 수 있어요! 🎮