4.1 운영체제의 발전

일괄 처리 → 대화식 처리 → 멀티프로그래밍 → 시분할 → 멀티코어 병렬

4.1.1 운영체제의 역할과 등장 배경

• 운영체제(OS): 하드웨어·소프트웨어 자원을 관리하고 프로그램이 돌아갈 환경을 깔아주는 시스템 소프트웨어. 프로그램은 하드웨어를 직접 못 건드리고 OS를 거침

  자원	OS의 역할
  CPU	스케줄링: 누구에게 먼저·얼마나 줄지
  메모리	할당·보호: 서로 침범 못 하게
  저장장치/파일	파일 시스템
  입출력 장치	장치 드라이버·I/O 제어

• 초기 컴퓨터: OS 없음, 사람이 직접 준비·실행·정리 → 준비하는 동안 CPU가 놂

• 운영자(Operator): 사용자 대신 작업을 모아(Batch) 연속으로 넣어주는 사람

• 상주 모니터(Resident Monitor): 초기 OS. 작업 적재·전환을 소프트웨어로 자동화

• 작업(Job): 한 번에 제출하는 처리 단위 = 프로그램 + 입력 데이터 + 지시사항(Control Commands)

4.1.2 일괄 처리와 대화식 처리

• 일괄 처리(Batch): 작업을 모아뒀다가 사용자 개입 없이 한 번에 처리. 예: 월말 급여 계산

  • 장점: CPU 유휴 시간 최소화, 처리량(Throughput) 극대화
  • 한계: 실행 중 상호작용 불가, 디버깅 어려움, 반환 시간(Turnaround Time) 김

• 작업 대기열(Job Queue): 실행 기다리는 작업 목록. FIFO만은 아님 (FCFS, 우선순위 등)

• 대화식 처리(Interactive): 실행 중에 입력 주고 바로 응답 받음. 예: 터미널에 ls → 바로 결과

  • 한계: 사용자가 입력 망설이는 동안 CPU 낭비

• 실시간 처리(Real-Time): 정해진 마감 시간(Deadline) 안에 반드시 끝내야 함. 예: 에어백 10ms

  구분	대화식	실시간
  목적	빠른 응답, 편의	마감 시간 준수
  늦으면	답답함	사고
  상대	사람	센서·기계

4.1.3 멀티프로그래밍과 시분할 방식

• 단일 작업 문제: I/O 기다리는 동안 CPU가 놂
  • 그림에서: 맨 위 줄 회색 idle 칸
• 멀티프로그래밍: 여러 프로그램을 메모리에 두고, 하나가 I/O 기다리면 다른 거 실행. 목적은 CPU 이용률
  • 그림에서: 가운데 줄, idle 자리에 B
• 시분할(Time Sharing): CPU 시간을 Time Slice로 잘라 번갈아 할당. 시간 다 되면 OS가 강제로 바꿈(선점). 목적은 빠른 응답
  • 그림에서: 맨 아래 줄, I/O 없어도 한 칸마다 바뀜
• 작업 바꿀 때마다 문맥 교환 필요

4.1.4 멀티태스킹과 병렬 실행

• 멀티태스킹: 한 시스템에서 여러 작업이 동시에 진행되도록 조정. 예: 문서 편집 + 음악
• 동시성(Concurrency): 논리적으로 동시에 도는 것처럼 보임. 코어 1개가 번갈아 실행
  • 그림에서: 위쪽 줄
• 병렬성(Parallelism): 물리적으로 같은 순간에 실제로 동시 실행. 코어 여러 개
  • 그림에서: 아래쪽 Core 1, Core 2

4.1.5 다양한 컴퓨팅 환경과 운영체제

• 다중 사용자 시분할 시스템: 여러 사용자가 단말기로 한 서버에 동시 접속. OS는 계정·권한, 보호(Isolation), 공정 배분 담당

• 시스템 관리자: 시스템을 관리하는 사람 (OS는 자원을 관리하는 소프트웨어)

• 다중 프로세서: CPU 칩 여러 개 / 다중 코어: 칩 하나에 코어 여러 개

  • OS 할 일: 스케줄링, 부하 균형(Load Balancing), 동기화
  • 한계: 직렬 부분은 병렬화 불가, 코어 간 통신 오버헤드 → 코어 수만큼 빨라지진 않음

• 임베디드 시스템: 특정 기능만 하는 내장 컴퓨터. 예: 자동차 ECU, 가전

  • 제약: 자원, 저전력, 고신뢰성, 실시간

• RTOS: 마감 시간 보장하는 OS. 핵심은 빠름이 아니라 예측 가능성

• 정리

  방식	해결한 문제	아이디어
  일괄 처리	사람이 준비하는 번거로움	모아서 자동 처리
  대화식	실행 중 상호작용 불가	즉시 입력·응답
  멀티프로그래밍	I/O 대기 중 CPU 유휴	I/O 대기 시 전환
  시분할	CPU 독점, 느린 응답	시간 잘게 나눠 번갈아

4.2 운영체제의 구조

4.2.1 사용자 공간과 커널(시스템 호출)

• SW 구분 기준: 설치된 컴퓨터가 아니라 하는 역할

  • 응용 SW: 사용자 일 처리. 문서 편집기, 브라우저, 게임, 내가 짠 C 코드
  • 시스템 SW: 하드웨어 관리, 개발·실행 지원. OS, 장치 드라이버, 컴파일러·링커, 유틸리티

• 유틸리티: 점검·관리 도구. 백업, 압축, 백신, 작업 관리자. OS에 포함되거나 따로 설치

• OS 없는 임베디드도 있음: 작은 온도·팬 제어 장치는 제어 프로그램이 레지스터·타이머·인터럽트까지 직접 처리

  • PC: 전원 → 펌웨어·부트 로더 → OS → 응용
  • OS 없음: 전원 → 시작 코드(초기화) → 제어 프로그램 → 측정·제어 반복

• UI: 사용자가 일 시키고 결과 받는 방법

  • CLI: 명령어 입력. 빠름, 스크립트 자동화, 자원 적게 씀. cmd, PowerShell, Bash
  • GUI: 창·아이콘·마우스. 쉽지만 메모리·GPU 더 씀

• 셸(Shell): 내가 친 명령을 해석해서 커널에 넘기는 명령 해석기. 사용자 공간 쪽

  • 하는 일: 명령어·인자 해석, 내장 명령 처리(cd, echo, exit), 외부 프로그램 실행 요청, 리다이렉션 >·파이프 |
  • hello.exe 입력 → 셸이 해석·파일 검색 → 커널이 시스템 호출 받아 프로세스 생성·메모리 할당 → 실행

• 사용자 공간: 응용·셸·관리 도구가 도는 곳. 계산·자기 메모리는 직접, 하드웨어는 못 만짐

  • 그림에서: 맨 위 파란 줄

• 커널: CPU·메모리·파일·장치 관리하고 프로그램끼리 침범 못 하게 막는 핵심 SW. 이중 모드(사용자/커널)로 보호

  • 4대 기능: 프로세스 관리, 메모리 관리, 파일 시스템 관리, 입출력 장치 제어
  • 그림에서: 보라색 줄

• 시스템 호출: 프로그램이 커널 기능을 안전하게 요청하는 통로. 커널이 처리 후 결과 반환

  • 그림에서: 빨간 점선, request / result 화살표

  종류	예
  파일	open(), read(), write()
  프로세스	fork(), exec(), exit()
  메모리	brk(), mmap()
  네트워크	socket(), connect()

• 사용자/커널 모드 = CPU 실행 권한 구분. root/admin 계정 구분이랑 다름

• C 파일 쓰기: C 프로그램(fopen, fputs, fclose) → 표준 라이브러리(open, write 호출) → 커널(권한 확인) → 드라이버 → SSD/HDD

  • C 표준 라이브러리 함수: OS가 아니라 언어가 주는 함수. 안에서 시스템 호출을 대신 불러줌(대행)
  • 시스템 프로그래밍에선 open(), write() 직접 호출하기도 함
  • 버퍼링: 출력을 매번 디스크로 안 보내고 메모리에 모았다가 한 번에. 입출력 횟수 줄이려고

4.2.2 파일 시스템과 입출력 제어

• 커널의 파일 관리: 생성·열기·읽기·쓰기·삭제, 메타데이터(이름, 크기, 권한, 시간), 디스크 속 실제 위치
• 디렉터리: 파일·하위 폴더를 이름으로 묶은 계층 구조
• 경로: 파일 위치 표현. C:\course\data\input.txt
• 파일 탐색기는 그냥 GUI 응용 프로그램. 실제로 읽고 쓰는 건 커널
• 파일 열기 순서: 요청 → 검증 → 반환 → 사용 → 종료
  • 요청: 경로 + 접근 방식(읽기/쓰기)
  • 검증: 파일 있는지, 권한 있는지
  • 반환: 고유한 값 줌. FILE *, 파일 디스크립터
  • 사용: 이후엔 경로 말고 그 값으로 읽기·쓰기
  • 종료: 닫아서 자원 반납
• 추상화: 프로그램은 섹터·물리 위치 몰라도 OS가 준 값으로만 접근
• 장치 드라이버: OS 표준 요청을 그 장치가 알아듣는 제어 동작으로 번역. 저장장치, 네트워크, 그래픽(VGA) 드라이버
  • 필요한 이유: 장치마다 명령 방식 다름(다양성), 앱·OS가 모든 장치를 알 필요 없음(편의성), 차이를 중간에서 숨김(추상화)
  • 흐름: 앱(fputs) → 커널(권한 확인) → 드라이버(장치 신호로 번역) → 장치 제어기·장치(실제 기록)

4.2.3 메모리 관리와 페이징

• 메모리 관리 역할: 할당, 논리 주소 ↔ 물리 주소 연결, 무단 접근 방지(보호), 끝난 프로그램 메모리 회수
• 주소 공간: 프로그램마다 따로 있는 공간. 코드·데이터·힙·스택. 허락 안 된 곳 접근하면 세그멘테이션 폴트
• malloc(): C 라이브러리 함수. 안에서 커널한테 메모리 요청
• 가상 메모리: 프로그램이 쓰는 주소(가상)랑 실제 RAM 주소(물리)를 분리
  • A, B 둘 다 가상 0x1000 써도 물리는 0x8000, 0xC000으로 달라서 안 부딪힘
• MMU: 메모리 접근할 때 가상 → 물리 변환 + 권한 검사하는 하드웨어
  • OS는 변환 정보·권한 설정, MMU는 그걸로 변환
  • 그림에서: 가운데 표 아래 설명
• 페이징: 가상 공간이랑 RAM을 같은 크기 고정 블록으로 나눠 관리. 크기는 시스템마다 다르고 4KiB가 흔함
  • 페이지: 가상 쪽 블록 / 프레임: 물리 쪽 블록 / 페이지 테이블: 페이지 → 프레임 연결 + 권한
  • 연속된 페이지가 RAM에선 떨어진 프레임에 들어가도 됨
  • 그림에서: 왼쪽 Page 0~2가 Frame 3, 0, 5로
• 요구 페이징: 처음에 다 안 올리고 필요한 페이지만 그때그때 RAM에
• 페이지 폴트: 접근하려는 페이지가 RAM에 없을 때 나는 예외
  • 유효한데 디스크에만 있음 → OS가 가져옴 / 잘못된 주소·권한 위반 → 세그멘테이션 폴트
  • 그림에서: 빨간 Page 3
• 페이지 폴트 처리 순서
  1. 가상 주소로 접근 시도
  2. RAM에 없음 → 페이지 폴트
  3. CPU가 예외 내고 제어권을 커널로
  4. OS가 유효성·권한 확인
  5. 빈 프레임 확보 (없으면 페이지 교체)
  6. 디스크에서 페이지를 프레임에 적재
  7. 페이지 테이블 갱신
  8. 멈췄던 명령 다시 실행
• 페이지 교체: RAM 꽉 차면 안 쓰는 페이지를 디스크로 내보내고(스왑 아웃) 프레임 확보
  • 새 페이지 필요 → 빈 프레임 부족 → 내보낼 페이지 선택 → 필요하면 디스크에 보관 → 연결 해제, 프레임 확보 → 새 페이지 올리고 연결
• 가상 메모리 장점: 주소 공간 분리·보호, RAM보다 큰 프로그램 실행(효율), RAM 배치 몰라도 됨(추상화)
• 스래싱: 메모리 너무 모자라서 스왑 인/아웃만 계속 반복. 계산보다 교체에 시간 다 써서 엄청 느려짐

4.2.4 프로세스 관리

• 스케줄러가 다음 작업을 고르고, 디스패처가 CPU를 넘김

4.2.5 GUI 윈도우 관리

• 창 제어: 위치·크기, 보이기/숨기기
• Z-order: 창 앞뒤 순서. 선택한 창이 맨 위로
• 포커스: 키보드·마우스 입력 받을 창 정하고 그 프로그램에 전달
  • 창 클릭 → 대상 창 확정 → 입력 → 그 프로그램으로 전달
• 창 배치·크기·화면 합성(겹치기, 투명)은 OS의 그래픽 서브시스템 담당
• GUI는 커널 필수 조건 아님. 화면 없는 리눅스 서버도 잘 돎
• Windows는 성능 때문에 커널 안에 GUI 일부 포함, Linux는 안정성·독립성 때문에 사용자 영역에 분리

4.2.6 운영체제의 구동 — 부팅

• 부팅: 전원 켜거나 재시작한 뒤 하드웨어 초기화하고 OS 실행까지

• 순서: 전원 → 펌웨어 → 부트 로더 → 커널 → 시스템 서비스·UI → 사용자 프로그램

  구성 요소	하는 일	저장 위치
  펌웨어(UEFI)	하드웨어 초기화, 부팅 대상(SSD/USB) 선택, 부트 로더를 RAM에 올리고 제어 넘김	메인보드 플래시 메모리(비휘발성)
  부트 로더	커널을 RAM에 올리고 제어 넘김	SSD 같은 저장장치
  커널	메모리·CPU·장치 관리 초기화, 시스템 서비스 실행	저장장치 → RAM

• 전원 켜면 CPU는 정해진 시작 위치의 코드(펌웨어)부터 실행

• 시스템 서비스: 로그인, 네트워크 등 / UI: 명령행이나 그래픽 화면

• BIOS: 옛날 PC에서 같은 역할 하던 펌웨어 방식. 지금은 대부분 UEFI

4.3 컴퓨팅 활동의 조정

4.3.1 프로그램과 프로세스

• 프로그램: 디스크에 저장된 실행 파일. 명령어 + 초기 데이터. 그 자체로는 안 돎(정적)

• 프로세스: 메모리에 올라가 실행 중인 프로그램 하나(인스턴스). OS가 만듦(동적)

  • 가진 것: 독립 주소 공간(Code·Data·Stack·Heap), CPU 실행 상태(PC, 레지스터), 제어 정보(PID, 상태), 시스템 자원(열린 파일 목록)

• 같은 example.exe를 두 번 실행하면 PID도 메모리 공간도 다른 프로세스 2개 (A: PID 101, B: PID 102)

• 프로세스 조정: 여러 프로세스가 CPU·메모리를 공정하게 나눠 안전하게 돌도록 OS가 관리하는 것

• 프로세스 메모리 구조

  영역	저장하는 것	특징
  Code	기계어 명령어	읽기 전용 (실행 중 수정 방지)
  Data	전역·정적(static) 변수	시작 때 할당, 끝날 때까지 유지
  Heap	동적 할당(malloc, new)	직접 해제해야 함, 안 하면 메모리 누수
  Stack	지역 변수, 매개변수, 리턴 주소	함수 호출 때 생기고 끝나면 자동 반환 (LIFO)

• 스택 vs 힙

  구분	Stack	Heap
  관리	컴파일러/OS (자동)	프로그래머/GC
  할당 시점	런타임, 함수 호출 때	런타임, 동적 할당 요청 때
  속도	빠름 (스택 포인터만 이동)	느림 (빈 곳 찾아야 함)
  크기	작음 (보통 수 MB)	큼 (가상 메모리 범위 안)
  문제	Stack Overflow	메모리 누수, 단편화

  • int a = 10;은 스택(자동 해제), malloc → free(p) → p = NULL은 힙(해제 필수, NULL은 댕글링 포인터 방지)

• 실행 문맥(Context): 멈춘 실행을 다시 이어가려고 기억해 둘 정보

  • PC: 다음에 실행할 명령어 주소 / 레지스터 값: 계산 중이던 값(i, sum) / SP: 스택 맨 위 위치 / 메모리 상태: 변수·스택·힙 값

• 문맥 vs 상태: 문맥은 이어가기 위한 정보(PC, 레지스터, SP), 상태는 지금 돌 수 있는지 분류(준비, 실행, 대기)

• PCB(프로세스 제어 블록): OS가 프로세스마다 만드는 관리용 자료구조

  • 담는 것: PID, 실행 상태, 저장된 실행 문맥, 스케줄링 정보(우선순위), 메모리 관리 정보, 자원 정보(열린 파일)

• 프로세스 테이블: 여러 PCB를 모아 관리하는 구조. 생성 때 새로 생기고, 종료 처리 끝나면 정리됨. 구현은 OS마다 다름

4.3.2 프로세스 상태와 상태전이

• 준비(Ready): CPU만 빼고 다 갖춤, CPU 배정 기다림. 준비 큐에서 대기

  • 그림에서: 파란 Ready

• 실행(Running): CPU 받아서 명령어 실행 중

  • 그림에서: 초록 Running

• 대기(Waiting/Blocked): I/O 완료 같은 사건 기다림, CPU 줘도 못 돎. 예: 파일 읽기 완료 대기

  • 그림에서: 노란 Waiting

• 준비 vs 대기: 준비는 CPU를 기다리고 CPU 받으면 바로 실행, 대기는 사건을 기다리고 CPU 받아도 못 돎

• 준비 큐: 커널 안에서 준비 상태 프로세스의 PCB(포인터)가 줄 선 곳. FIFO, 우선순위 큐, 다단계 큐 등

• 언제 어디로 가냐

  전이	언제
  생성 → 준비	메모리에 올라가고 준비 끝
  준비 → 실행	스케줄러가 고르고 디스패처가 넘김
  실행 → 준비	할당 시간 끝 (타이머 인터럽트)
  실행 → 대기	I/O 요청
  대기 → 준비	I/O 끝 (I/O 인터럽트)
  실행 → 종료	실행 완료

• I/O 끝나도 바로 실행 아님. 반드시 준비를 거쳐서 스케줄러가 골라야 실행

  • 그림에서: 아래 I/O done 화살표가 Ready로 감

4.3.3 CPU 스케줄링과 할당 시간

• CPU 스케줄러: 준비 큐에서 다음에 CPU 쓸 애를 고름. 순서·우선순위 같은 정책대로
• 디스패처: 고른 애한테 CPU를 실제로 넘김. 문맥 교환 → 커널 모드에서 사용자 모드로 → 그 프로세스 주소 공간으로 바꿈 → 저장해둔 PC부터 이어서 실행
• 흐름: 준비 → 스케줄러("누구?") → 디스패처("너 실행") → CPU
• 할당 시간(Time Slice/Quantum): 한 프로세스가 연속으로 CPU 쓸 수 있는 시간 단위. 대표 정책은 라운드 로빈. 길이는 OS·정책마다 다름
• 할당 시간 만료 시 순서
  1. 타이머 인터럽트 발생
  2. OS가 CPU 사용 시간 확인
  3. 현재 프로세스를 준비로
  4. 스케줄러가 다음 프로세스 선택
• 다 안 써도 됨: 중간에 I/O 생기면 대기로, 끝나면 바로 CPU 반납. 할당 시간은 채워야 하는 시간이 아니라 허용 구간

4.3.4 인터럽트와 문맥 교환

• 하드웨어 인터럽트: 장치에서 생긴 사건을 CPU에 알리는 방법. 예: 타이머(할당 시간 만료), I/O 완료(디스크, 네트워크)

• 처리 흐름: 사용자 프로그램 실행 → 인터럽트 → 복귀 정보(Context) 저장 → 커널의 인터럽트 처리 코드 → 원래 프로세스 재개 or (필요하면) 다른 프로세스로 문맥 교환

• 셋 구분

  종류	원인	예
  하드웨어 인터럽트	타이머·외부 장치	타이머 만료, I/O 완료
  시스템 호출	프로그램이 OS 서비스 요청	파일 읽기·쓰기, 프로세스 생성
  예외	지금 실행 중인 명령어에서 생긴 사건	페이지 폴트, 0으로 나누기, 잘못된 명령

  • I/O 요청은 시스템 호출로, I/O 완료는 장치 인터럽트로 알림

• 문맥 교환(Context Switch): CPU에서 돌 프로세스를 바꾸는 절차. 지금 거 문맥 저장 + 다음 거 문맥 복원

  • A 실행 → 인터럽트/타임 슬라이스 만료 → 커널로 → A 문맥을 PCB에 저장(PC, 레지스터, SP) → 스케줄러가 B 선택 → B 문맥 복원(주소 공간 전환 포함) → B 실행

• 오해: A 메모리를 B로 복사하는 거 아님. A, B 둘 다 자기 공간은 메모리에 그대로 있음

• 문맥 교환 오버헤드: 레지스터 저장·복원, 권한·주소 전환에 드는 CPU 시간. 그동안 사용자 프로그램 계산은 안 됨

• 라운드 로빈(RR): 모두 같은 할당 시간만큼 돌아가며 CPU 사용. 선점형(시간 지나면 강제로 뺏음). 공평 + 빠른 응답

  • 큐 맨 앞이 정해진 시간(예: 10ms)만큼 실행 → 시간 안에 끝나면 종료, 못 끝내면 큐 맨 뒤로 (할당 시간 만료 순서)
  • 할당 시간 너무 길면 선착순이랑 같아짐 / 너무 짧으면 문맥 교환만 하다 끝남

• 선착순 vs 선점형

  구분	선착순(FCFS, 비선점)	선점형(Preemptive)
  CPU 제어권	프로세스가 스스로 반납	OS가 강제로 회수 가능
  비유	은행 창구 줄	발언 시간 제한 토론
  장점	단순, 문맥 교환 적음	빠른 응답, 멀티태스킹
  단점	대기 시간 김	문맥 교환 오버헤드
  예	FCFS, 일괄 처리	RR, Windows, Linux

4.3.5 입출력 대기와 다중 프로그래밍

• 프로그램 실행 전체 흐름

  1. 메모리 적재: 로더(OS)가 .exe를 메모리에 올림, 주소 공간 할당, PCB 만들고 시작 주소를 PC 칸에
  2. 준비: CPU 빼고 자원 다 받음, 준비 큐 등록
  3. CPU 배정: 스케줄러 선택 → 디스패처가 PCB의 PC·레지스터를 CPU에 복원, 제어권 전달
  4. 실행: 인출 → 해석 → 실행 반복

• 다중 프로그래밍을 상태 전이로 보면: A가 I/O 기다리는 시간을 B 실행 시간으로 바꿔서 CPU가 안 놂

• A → B → A 흐름

  1. I/O 요청: 실행 중인 A가 I/O 요청
  2. 대기 전환: OS가 A를 대기로
  3. 스케줄링·디스패치: 준비 큐의 B 선택, B 실행
  4. I/O 완료: OS가 A를 준비로
  5. 실행 재개: 스케줄러가 다시 A 고르면 A 실행

  시간 →	1	2	3
  CPU	A 계산	B 계산	A 계산
  I/O 장치		A의 I/O
  A 상태	실행	대기	실행
  B 상태	준비	실행	준비