Hanpy's Blog

두 글자 이상 입력하세요.

CS 기초 · 운영체제

CPU 스케줄링: 알고리즘 비교와 리눅스 nice 실험

실행할 수 있는 스레드가 CPU보다 많을 때 운영체제는 누구에게 먼저 CPU를 줄까요? FCFS·SJF·RR·우선순위·MLFQ를 같은 작업 목록으로 시뮬레이션해 비교하고, 리눅스에서 nice 값을 바꿔 CPU 몫이 가중치대로 나뉘는지와 autogroup 때문에 nice가 안 먹는 경우를 직접 확인합니다.

Hanpy약 14분
시리즈운영체제 기초2 / 3
  1. 01프로세스와 스레드: ps와 top -H로 직접 확인하기
  2. 02CPU 스케줄링: 알고리즘 비교와 리눅스 nice 실험지금 읽는 글
  3. 03컨텍스트 스위칭: 무엇을 저장하고 얼마나 비쌀까
시리즈 목차 보기 →

1편에서 아무 일도 하지 않는 Node.js 프로세스 하나에 스레드가 7개 있는 것을 봤습니다. 서버 한 대에는 이런 프로세스가 수십~수백 개 돌고 있으니, 실행할 수 있는 스레드는 늘 CPU 코어보다 많습니다. 그렇다면 지금 이 순간 어느 스레드가 CPU를 쓸지는 누가, 어떤 기준으로 정할까요? 이 일을 하는 것이 운영체제의 CPU 스케줄러입니다.

1편: 프로세스와 스레드 다시 보기 (클릭)

이 글에서는 교과서의 대표 알고리즘 다섯 가지를 정리하고, 직접 만든 시뮬레이터로 같은 작업 목록을 돌려 결과를 비교합니다. 그다음 리눅스에서 nice 값을 바꿔 가며 CPU 시간이 정말 가중치대로 나뉘는지 측정하고, 많은 사람이 모르는 "다른 터미널에서 실행하면 nice가 안 먹는" 경우도 확인합니다. 실습은 Ubuntu 24.04(커널 6.18, Firecracker VM), CPU 2개, gcc 13·Node.js 22 환경에서 실행했고 출력은 그대로 옮겼습니다.

스케줄러가 하는 일

1편의 프로세스 상태를 떠올려 보면, 준비(Ready) 상태의 스레드들은 CPU 차례를 기다리며 줄(준비 큐)을 서 있습니다. 스케줄러는 이 줄에서 다음에 실행할 스레드를 고릅니다. 고르는 순간은 크게 네 가지입니다.

  1. 실행 중인 스레드가 I/O를 요청하거나 잠들 때 (실행 → 대기)
  2. 실행 중인 스레드의 차례가 끝났을 때 (실행 → 준비)
  3. 기다리던 I/O가 끝나 스레드가 깨어났을 때 (대기 → 준비)
  4. 실행 중인 스레드가 끝났을 때 (종료)

1과 4에서만 고르는 방식을 비선점(non-preemptive), 2·3처럼 실행 중인 스레드를 중간에 끌어내릴 수도 있는 방식을 선점(preemptive) 스케줄링이라고 합니다. 비선점은 단순하지만 한 스레드가 CPU를 오래 붙잡으면 나머지가 모두 기다려야 합니다. 리눅스를 포함한 요즘 범용 운영체제는 선점 방식입니다.

무엇을 좋게 만들려고 하나

기준뜻좋은 방향
CPU 이용률CPU가 일하는 시간의 비율높게
처리량단위 시간에 끝나는 작업 수높게
반환 시간작업이 도착해서 끝날 때까지 걸린 시간짧게
대기 시간준비 큐에서 기다린 시간의 합짧게
응답 시간도착해서 처음 CPU를 받기까지 걸린 시간짧게

이 기준들은 서로 부딪힙니다. 예를 들어 응답 시간을 줄이려고 스레드를 자주 바꾸면, 바꾸는 비용(다음 글의 컨텍스트 스위칭) 때문에 처리량이 떨어집니다. 그래서 "가장 좋은 알고리즘"은 없고, 무엇을 우선할지에 따라 고릅니다.

CPU를 쓰는 작업, 기다리는 작업

프로그램은 CPU로 계산하는 구간(CPU 버스트)과 디스크·네트워크를 기다리는 구간(I/O 버스트)을 번갈아 오갑니다. 계산이 대부분인 프로그램(압축, 이미지 처리)을 CPU 중심(CPU-bound), 기다림이 대부분인 프로그램(웹 서버, DB 클라이언트)을 I/O 중심(I/O-bound)이라고 부릅니다. 좋은 스케줄러는 I/O 중심 작업을 빨리 돌려 보내 다시 I/O를 시작하게 하고, 그동안 CPU 중심 작업이 CPU를 쓰게 합니다.

대표 알고리즘 다섯 가지

알고리즘고르는 방법선점장점문제
FCFS (First-Come, First-Served)먼저 온 순서대로X단순, 공평해 보임긴 작업 뒤에 짧은 작업이 줄줄이 기다림(호위 효과, convoy effect)
SJF (Shortest Job First)실행 시간이 가장 짧은 작업 먼저X평균 대기 시간이 가장 짧음(비선점 중)실행 시간을 미리 알 수 없음, 긴 작업이 계속 밀리는 기아(starvation)
SRTF (Shortest Remaining Time First)남은 시간이 가장 짧은 작업 먼저OSJF의 선점판, 새로 온 짧은 작업이 바로 실행SJF와 같은 문제 + 잦은 교체
RR (Round Robin)정해진 시간(타임 퀀텀)만큼씩 돌아가며O응답 시간이 고름, 기아 없음퀀텀이 너무 크면 FCFS, 너무 작으면 교체 비용만 늘어남
우선순위 + MLFQ우선순위가 높은 줄 먼저, 행동에 따라 줄을 옮김OI/O 중심 작업에 빠른 응답낮은 우선순위의 기아 → 기다린 만큼 올려 주는 에이징(aging) 필요

MLFQ(Multi-Level Feedback Queue)는 우선순위가 다른 줄을 여러 개 두고, 퀀텀을 다 써 버리는 작업은 아래 줄로 내리고 금방 CPU를 내놓는 작업은 위 줄에 남깁니다. 실행 시간을 미리 몰라도 행동을 보고 CPU 중심인지 I/O 중심인지 추측하는 방식입니다.

실습 1: 같은 작업 목록을 다섯 가지로 돌려 보기

표만 보면 감이 잘 오지 않아서, 작업 목록을 넣으면 알고리즘마다 평균 대기·응답 시간을 계산하는 시뮬레이터를 만들었습니다. 작업은 오래 걸리는 계산 A(24ms)와 짧은 요청 B·C(각 3ms) 세 개입니다. 웹 서버로 치면 무거운 배치 작업 하나와 가벼운 API 요청 두 개입니다.

sched-sim.mjs
// sched-sim.mjs: FCFS·SJF·SRTF·RR을 같은 작업 목록으로 돌려 보고 평균 대기·응답 시간을 비교한다
// 작업: [이름, 도착 시각, CPU 사용 시간] (단위 ms)
// 상황 1: 셋이 동시에 도착 / 상황 2: 긴 작업 A가 1ms 먼저 도착
const scenarios = {
  '상황 1 (동시 도착)': [['A', 0, 24], ['B', 0, 3], ['C', 0, 3]],
  '상황 2 (A가 먼저)': [['A', 0, 24], ['B', 1, 3], ['C', 2, 3]],
}
 
function fcfs(list) {
  let t = 0
  const out = []
  for (const [name, arrive, burst] of [...list].sort((a, b) => a[1] - b[1])) {
    const start = Math.max(t, arrive)
    t = start + burst
    out.push({ name, arrive, burst, start, end: t })
  }
  return out
}
 
// 비선점 SJF: CPU가 비면 도착한 작업 중 가장 짧은 것을 고른다
function sjf(list) {
  const left = [...list]
  let t = 0
  const out = []
  while (left.length) {
    const ready = left.filter((j) => j[1] <= t)
    if (!ready.length) { t = Math.min(...left.map((j) => j[1])); continue }
    const job = ready.sort((a, b) => a[2] - b[2])[0]
    left.splice(left.indexOf(job), 1)
    const [name, arrive, burst] = job
    out.push({ name, arrive, burst, start: t, end: t + burst })
    t += burst
  }
  return out
}
 
// SRTF(선점 SJF): 1ms마다 남은 시간이 가장 짧은 작업을 실행
function srtf(list) {
  const info = list.map(([name, arrive, burst]) => ({ name, arrive, burst, left: burst, start: null, end: null }))
  let t = 0
  while (info.some((j) => j.left > 0)) {
    const ready = info.filter((j) => j.arrive <= t && j.left > 0)
    if (!ready.length) { t++; continue }
    const j = ready.sort((a, b) => a.left - b.left)[0]
    if (j.start === null) j.start = t
    j.left--
    t++
    if (j.left === 0) j.end = t
  }
  return info
}
 
// RR: 정해진 시간(q)만큼 돌리고 큐 뒤로 보낸다
function rr(list, q) {
  const pending = [...list].sort((a, b) => a[1] - b[1])
  const queue = []
  const info = new Map(list.map(([n, a, b]) => [n, { name: n, arrive: a, burst: b, left: b, start: null, end: null }]))
  let t = 0
  const admit = () => { while (pending.length && pending[0][1] <= t) queue.push(info.get(pending.shift()[0])) }
  admit()
  while (queue.length || pending.length) {
    if (!queue.length) { t = pending[0][1]; admit(); continue }
    const j = queue.shift()
    if (j.start === null) j.start = t
    const run = Math.min(q, j.left)
    t += run
    j.left -= run
    admit() // 실행 중에 도착한 작업이 먼저 줄을 선다
    if (j.left > 0) queue.push(j)
    else j.end = t
  }
  return [...info.values()]
}
 
function report(label, rows) {
  const avg = (f) => (rows.reduce((s, r) => s + f(r), 0) / rows.length).toFixed(1)
  const wait = (r) => r.end - r.arrive - r.burst // 준비 큐에서 기다린 시간
  const resp = (r) => r.start - r.arrive // 처음 CPU를 받기까지
  console.log(`${label.padEnd(10)} 평균 대기 ${avg(wait).padStart(5)}ms  평균 응답 ${avg(resp).padStart(5)}ms  끝난 순서 ${[...rows].sort((a, b) => a.end - b.end).map((r) => `${r.name}@${r.end}`).join(' ')}`)
}
 
for (const [title, jobs] of Object.entries(scenarios)) {
  console.log(`# ${title}`)
  report('FCFS', fcfs(jobs))
  report('SJF', sjf(jobs))
  report('SRTF', srtf(jobs))
  report('RR q=4', rr(jobs, 4))
  report('RR q=1', rr(jobs, 1))
}
실행 결과 (직접 실행)
$ node sched-sim.mjs
# 상황 1 (동시 도착)
FCFS       평균 대기  17.0ms  평균 응답  17.0ms  끝난 순서 A@24 B@27 C@30
SJF        평균 대기   3.0ms  평균 응답   3.0ms  끝난 순서 B@3 C@6 A@30
SRTF       평균 대기   3.0ms  평균 응답   3.0ms  끝난 순서 B@3 C@6 A@30
RR q=4     평균 대기   5.7ms  평균 응답   3.7ms  끝난 순서 B@7 C@10 A@30
RR q=1     평균 대기   5.7ms  평균 응답   1.0ms  끝난 순서 B@8 C@9 A@30
# 상황 2 (A가 먼저)
FCFS       평균 대기  16.0ms  평균 응답  16.0ms  끝난 순서 A@24 B@27 C@30
SJF        평균 대기  16.0ms  평균 응답  16.0ms  끝난 순서 A@24 B@27 C@30
SRTF       평균 대기   2.7ms  평균 응답   0.7ms  끝난 순서 B@4 C@7 A@30
RR q=4     평균 대기   4.7ms  평균 응답   2.7ms  끝난 순서 B@7 C@10 A@30
RR q=1     평균 대기   5.0ms  평균 응답   0.3ms  끝난 순서 B@8 C@10 A@30

결과에서 읽을 수 있는 것은 네 가지입니다.

  • FCFS의 호위 효과: A가 앞에 있으면 3ms짜리 B·C가 24ms를 기다립니다. 평균 대기가 16~17ms로 가장 나쁩니다.
  • 비선점 SJF의 한계: 상황 1에서는 짧은 것부터 실행해 평균 대기 3ms로 가장 좋습니다. 그런데 A가 단 1ms 먼저 도착한 상황 2에서는 A가 이미 CPU를 잡았기 때문에 FCFS와 똑같아집니다. 실행 중인 작업을 끌어내릴 수 없기 때문입니다.
  • 선점의 힘: SRTF는 B가 도착하자마자 A를 멈추고 B를 실행해서, 상황 2에서도 평균 대기 2.7ms가 됩니다. 다만 SRTF는 각 작업이 얼마나 걸릴지 미리 알아야 해서 현실에서는 그대로 쓸 수 없습니다.
  • RR의 퀀텀: 실행 시간을 몰라도 B·C가 7~10ms 안에 끝납니다. 퀀텀을 4ms에서 1ms로 줄이면 응답 시간(처음 CPU를 받기까지)은 더 짧아지지만 평균 대기는 오히려 조금 늘었습니다. 게다가 이 시뮬레이터는 교체 비용을 0으로 계산합니다. 실제로는 교체할 때마다 비용이 드니(다음 글에서 직접 잽니다) 퀀텀을 무작정 줄일 수 없습니다. 모든 알고리즘에서 A는 똑같이 30ms에 끝난다는 점도 눈여겨볼 만합니다. 순서를 바꿔도 CPU가 해야 할 일의 총량은 같고, 누가 기다리느냐만 달라집니다.

리눅스의 스케줄러

리눅스는 하나의 알고리즘이 아니라 스케줄링 정책 여러 개를 두고, 정책마다 다른 클래스가 처리합니다. chrt -m으로 이 시스템이 지원하는 정책을 볼 수 있습니다.

정책과 우선순위 범위 (직접 실행)
$ chrt -m
SCHED_OTHER min/max priority	: 0/0
SCHED_FIFO min/max priority	: 1/99
SCHED_RR min/max priority	: 1/99
SCHED_BATCH min/max priority	: 0/0
SCHED_IDLE min/max priority	: 0/0
SCHED_DEADLINE min/max priority	: 0/0
 
$ chrt -p $$
pid 195's current scheduling policy: SCHED_OTHER
pid 195's current scheduling priority: 0
 
$ cat /proc/sys/kernel/sched_rr_timeslice_ms
100
정책대상고르는 방식
SCHED_OTHER (기본) · SCHED_BATCH · SCHED_IDLE일반 프로그램 거의 전부공평 분배(아래). 우선순위 대신 nice 값(-20~19)으로 몫을 조절
SCHED_FIFO · SCHED_RR실시간 작업(오디오, 제어)우선순위 1~99가 높은 것이 무조건 먼저. RR은 같은 우선순위끼리 퀀텀(이 시스템은 100ms)으로 돌아감
SCHED_DEADLINE마감 시간이 있는 주기 작업마감이 가장 가까운 작업 먼저

우리가 실행하는 서버 프로그램은 대부분 SCHED_OTHER입니다. 이 정책은 오랫동안 CFS(Completely Fair Scheduler)가 맡았고, 리눅스 커널은 6.6 버전부터 CFS에서 Peter Zijlstra가 2023년에 제안한 EEVDF(Earliest Eligible Virtual Deadline First)로 옮겨 가기 시작했습니다. 둘 다 생각은 같습니다. EEVDF도 CFS처럼 같은 우선순위의 실행 가능한 작업들에게 CPU 시간을 고르게 나누는 것을 목표로 합니다.

  • 각 스레드가 CPU를 쓴 시간을 가상 실행 시간(vruntime)으로 기록합니다. 가중치가 큰(nice가 낮은) 스레드는 같은 시간을 써도 vruntime이 천천히 늘어납니다.
  • 이 가상 실행 시간으로 'lag' 값을 만들어, 양수면 받아야 할 CPU 시간이 남은 것이고 음수면 몫보다 더 쓴 것으로 봅니다.
  • EEVDF는 lag이 0 이상인 작업들의 가상 마감 시각(virtual deadline)을 계산해, 마감이 가장 이른 작업을 다음으로 실행합니다.

교과서 알고리즘과 연결하면, 고정된 퀀텀 대신 "지금까지 덜 받은 쪽"에 CPU를 주는 공평 분배 방식이고, 선점이 있으며, 오래 잠들어 있던 I/O 중심 스레드가 깨어나면 빨리 차례를 받습니다. 각 스레드의 스케줄링 정보는 /proc/<PID>/sched에서 볼 수 있습니다.

/proc/self/sched 일부 (직접 실행)
$ head -30 /proc/self/sched
head (207, #threads: 1)
-------------------------------------------------------------------
se.exec_start                                :         52790.249697
se.vruntime                                  :            74.202724
se.sum_exec_runtime                          :             0.774652
se.nr_migrations                             :                    0
nr_switches                                  :                    0
nr_voluntary_switches                        :                    0
nr_involuntary_switches                      :                    0
se.load.weight                               :              1048576
...
prio                                         :                  120
se.slice                                     :              1400000

se.vruntime이 가상 실행 시간, se.load.weight가 가중치입니다. 이 값은 내부적으로 1024배(10비트) 키워 저장되어 있어서 1048576 ÷ 1024 = 1024가 nice 0의 가중치입니다. prio 120은 nice 0을 커널 내부 번호로 바꾼 값(100 + 20 + nice)입니다.

실습 2: nice로 CPU 몫을 나눠 보기

nice 값이 정말 CPU 시간을 가중치대로 나누는지 재 봤습니다. 10초 동안 CPU만 쓰는 C 프로그램을 만들고, taskset -c 0으로 둘 다 CPU 0번에만 붙여 경쟁시킵니다. 하나는 nice 0, 다른 하나는 nice 5와 10으로 바꿔 가며 실행했습니다.

spin.c
// spin.c: CPU를 계속 쓰는 프로그램 (N초 뒤 끝남)
#include <stdlib.h>
#include <time.h>
int main(int argc, char **argv) {
  int sec = argc > 1 ? atoi(argv[1]) : 10;
  time_t end = time(NULL) + sec;
  volatile unsigned long x = 0;
  while (time(NULL) < end) for (int i = 0; i < 1000000; i++) x++;
  return 0;
}
같은 CPU에서 nice 0 vs nice 5, nice 0 vs nice 10 (직접 실행)
$ gcc -O2 -o spin spin.c
$ taskset -c 0 ./spin 10 & taskset -c 0 nice -n 5 ./spin 10 &
$ sleep 9; ps -o pid,ni,pri,psr,pcpu,time,comm -p <두 PID>
  PID  NI PRI PSR %CPU     TIME COMMAND
  209   0  19   0 74.5 00:00:06 spin
  210   5  14   0 24.4 00:00:02 spin
$ grep -h se.load.weight /proc/209/sched /proc/210/sched
se.load.weight                               :              1048576
se.load.weight                               :               343040
$ awk '{print "pid", $1, "utime(ticks)=" $14}' /proc/209/stat /proc/210/stat
pid 209 utime(ticks)=673
pid 210 utime(ticks)=220
 
# nice 10으로 바꿔서 다시
  PID  NI PRI PSR %CPU     TIME COMMAND
  221   0  19   0 89.7 00:00:08 spin
  222  10   9   0  9.6 00:00:00 spin
se.load.weight                               :              1048576
se.load.weight                               :               112640
pid 221 utime(ticks)=809
pid 222 utime(ticks)=87

가중치(÷1024)로 기대 몫을 계산해 실측과 나란히 놓으면 이렇습니다(utime은 1/100초 단위 CPU 사용 시간).

조합가중치기대 몫 (nice 0 쪽)실측 몫 (utime)
nice 0 vs nice 51024 : 3351024 / 1359 = 75.3%673 / 893 = 75.4%
nice 0 vs nice 101024 : 1101024 / 1134 = 90.3%809 / 896 = 90.3%

계산과 실측이 소수점 첫째 자리까지 맞습니다. nice가 1 오를 때마다 가중치는 약 1.25배씩 줄어서, nice 5는 nice 0의 약 1/3, nice 10은 약 1/9만큼만 CPU를 받습니다.

CPU가 남으면 nice는 의미가 없다

같은 실험을 taskset 없이, 즉 CPU 2개를 다 쓸 수 있게 돌리면 결과가 다릅니다.

CPU 2개, 고정하지 않음 (직접 실행)
$ ./spin 6 & nice -n 10 ./spin 6 &
$ ps -o pid,ni,psr,pcpu,comm -p <두 PID>
  PID  NI PSR %CPU COMMAND
  256   0   0 99.2 spin
  257  10   1 98.6 spin

스케줄러가 두 프로그램을 서로 다른 CPU(PSR 0과 1)에 나눠 놓아서 둘 다 거의 100%를 씁니다. nice는 CPU를 두고 경쟁할 때만 몫을 정합니다. "배치 작업을 nice 19로 돌렸으니 서버가 안전하다"는 생각은, CPU가 남는 동안에는 맞지만 메모리·디스크 I/O·CPU 캐시를 함께 쓰는 영향까지 막아 주지는 않습니다.

광고

실습 3: 다른 터미널에서 실행하면 nice가 안 먹는다

이번에는 실습 2와 똑같이 CPU 0번에서 nice 0과 nice 10을 경쟁시키되, nice 10 쪽만 setsid로 다른 세션에서 실행했습니다. 다른 터미널 창이나 다른 SSH 접속에서 실행한 것과 같은 상황입니다.

같은 CPU, nice 10을 다른 세션에서 (직접 실행)
$ taskset -c 0 ./spin 8 &
$ setsid taskset -c 0 nice -n 10 ./spin 8 &
$ ps -o pid,sid,ni,psr,pcpu,comm -p 260,263
  PID   SID  NI PSR %CPU COMMAND
  260   255   0   0 49.3 spin
  263   263  10   0 49.8 spin
$ cat /proc/260/autogroup /proc/263/autogroup
/autogroup-9 nice 0
/autogroup-10 nice 0
$ cat /proc/sys/kernel/sched_autogroup_enabled
1

nice 10인데도 50 : 50입니다. 원인은 리눅스의 autogroup 기능입니다. 데스크톱 반응성을 위해 세션(터미널)마다 프로세스를 하나의 그룹으로 묶고, CPU를 먼저 그룹끼리 공평하게 나눈 뒤 그룹 안에서 nice로 나눕니다. /proc/<PID>/autogroup을 보면 두 프로세스가 서로 다른 그룹(9, 10)에 들어 있습니다. sched(7) 매뉴얼도 nice(1)은 같은 세션(보통 같은 터미널 창)에서 실행된 다른 프로세스와 비교할 때만 스케줄링에 영향을 준다고 적고 있고, 이 문서를 고친 매뉴얼 관리자는 nice가 거의 쓸모없어진다며 이 동작에 놀랄 사람이 자기만은 아닐 것이라고 말하기도 했습니다.

실무에서는 이렇게 정리할 수 있습니다.

  • 같은 셸 스크립트 안에서 띄운 작업끼리는 nice가 기대대로 동작합니다.
  • 다른 터미널·다른 cron 작업·다른 서비스와 비교해 몫을 조절하려면 nice 대신 cgroup을 씁니다. cgroups(7) CPU 컨트롤러로 프로세스를 루트가 아닌 cgroup에 넣으면 autogroup의 효과를 덮어씁니다. systemd 서비스의 CPUWeight=, 쿠버네티스 파드의 resources.requests.cpu가 모두 cgroup으로 CPU 몫을 정하는 방식입니다.
  • 서버 배포판이나 컨테이너 안에서는 프로세스가 이미 cgroup에 들어 있는 경우가 많아 autogroup이 영향을 주지 않을 수 있습니다. 내 서버에서 어떤지는 /proc/sys/kernel/sched_autogroup_enabled와 /proc/<PID>/autogroup으로 확인하세요.

Node.js 개발자에게 주는 의미

Node.js의 자바스크립트는 메인 스레드 하나에서 돌기 때문에, 운영체제 스케줄러가 아무리 공평해도 프로세스 안에서는 FCFS처럼 동작합니다. 요청 하나가 무거운 계산(큰 JSON 처리, 암호화, 이미지 변환)으로 메인 스레드를 200ms 붙잡으면, 그동안 도착한 가벼운 요청들은 실습 1의 B·C처럼 줄줄이 기다립니다. 운영체제가 해 주는 선점은 스레드 사이에만 일어나지, 이벤트 루프 안의 콜백 사이에는 일어나지 않습니다.

그래서 1편에서 본 것처럼 CPU를 오래 쓰는 일은 워커 스레드나 별도 프로세스로 빼서 운영체제 스케줄러가 나눠 주게 하는 것이 기본 해법입니다. 여러 요청이 공유 자원에 동시에 접근할 때의 문제는 이 시리즈 4편(동기화)과 기존 동시성 제어 글에서 이어집니다.

DB 동시성 제어 시리즈 보기 (클릭)

실무에서 겪은 일

작업 1만 개를 한꺼번에 돌리면 그만큼 느려집니다. 스케줄러는 준비 큐에 들어온 작업들에 CPU를 나눠 주기 때문에, 한 번에 다 넣으면 하나하나가 끝나는 시간이 다 같이 늦어지고 같은 서버에서 도는 API 응답도 함께 밀립니다. 쿠버네티스의 CPU requests·limits도 처음부터 계산으로 정하기보다, 보통 일주일 정도 실제로 돌려 보고 사용량을 본 다음 정합니다.

정리

  • CPU 스케줄러는 준비 큐에서 다음에 실행할 스레드를 고릅니다. 실행 중인 스레드를 중간에 끌어내릴 수 있으면 선점, 없으면 비선점입니다.
  • FCFS는 긴 작업 뒤에서 짧은 작업이 기다리는 호위 효과, SJF는 실행 시간을 미리 알아야 하는 문제와 기아, RR은 퀀텀 크기와 교체 비용 사이의 균형 문제가 있습니다. 시뮬레이션에서 비선점 SJF는 긴 작업이 1ms 먼저 오기만 해도 FCFS와 같아졌습니다.
  • 리눅스의 일반 프로그램(SCHED_OTHER)은 가상 실행 시간으로 CPU를 공평하게 나누는 스케줄러가 맡고, 6.6부터 CFS에서 EEVDF로 옮겨 가고 있습니다. 실시간 정책(SCHED_FIFO·SCHED_RR)은 우선순위가 높은 것이 무조건 먼저입니다.
  • nice는 가중치를 바꿉니다. 같은 CPU에서 nice 0 대 5는 75 : 25, 0 대 10은 90 : 10으로 계산과 실측이 일치했습니다. 단, CPU가 남으면 효과가 없고, autogroup이 켜져 있으면 다른 세션의 프로세스와는 nice가 비교되지 않습니다(50 : 50). 서비스 사이의 CPU 몫은 cgroup으로 정합니다.
  • 다음 글에서는 스케줄러가 스레드를 바꿀 때 실제로 무슨 일이 일어나고, 그 비용이 얼마인지 컨텍스트 스위칭을 직접 재 봅니다.

참고 자료

이 글은 AI 도구로 초안을 만들고 저자가 검토·보완했습니다.