캐시와 버퍼: 속도 차이를 극복하는 두 가지 방법

1
// 시간 지역성 예시
2
int sum = 0;
3
for (int i = 0; i < 1000; i++) {
4
    sum += array[i];  // sum 변수는 반복적으로 접근됨
5
}

1
// 공간 지역성 예시
2
int[] array = new int[1000];
3
for (int i = 0; i < 1000; i++) {
4
    sum += array[i];  // 연속된 메모리 주소 접근
5
}

1
사용자 입력:  H → e → l → l → o [Enter]
2
                ↓
3
키보드 버퍼: [H][e][l][l][o][\n]
4
                ↓
5
프로그램:     "Hello\n" 읽기

1
// 버퍼 없이 디스크 쓰기
2
for (int i = 0; i < 1000; i++) {
3
    disk.write(data[i]);  // 매번 디스크 접근 (매우 느림)
4
}
5

6
// 버퍼를 사용한 디스크 쓰기
7
BufferedWriter writer = new BufferedWriter(new FileWriter("file.txt"));
8
for (int i = 0; i < 1000; i++) {
9
    writer.write(data[i]);  // 버퍼에 쓰기 (빠름)
10
}
11
writer.flush();  // 버퍼의 내용을 한 번에 디스크로

1
// TCP 소켓 버퍼 크기 설정
2
Socket socket = new Socket();
3
socket.setSendBufferSize(65536);     // 송신 버퍼: 64KB
4
socket.setReceiveBufferSize(65536);  // 수신 버퍼: 64KB

1
typedef struct {
2
    char buffer[BUFFER_SIZE];
3
    int read_pos;
4
    int write_pos;
5
    int count;  // 현재 저장된 데이터 개수
6
} RingBuffer;
7

8
void ring_buffer_write(RingBuffer* rb, char data) {
9
    if (rb->count < BUFFER_SIZE) {
10
        rb->buffer[rb->write_pos] = data;
11
        rb->write_pos = (rb->write_pos + 1) % BUFFER_SIZE;
12
        rb->count++;
13
    }
14
}
15

16
char ring_buffer_read(RingBuffer* rb) {
17
    if (rb->count > 0) {
18
        char data = rb->buffer[rb->read_pos];
19
        rb->read_pos = (rb->read_pos + 1) % BUFFER_SIZE;
20
        rb->count--;
21
        return data;
22
    }
23
    return -1;  // 버퍼가 비어있음
24
}

1
// 공유 버퍼
2
class SharedBuffer {
3
    private Queue<Integer> buffer = new LinkedList<>();
4
    private int capacity;
5

6
    public SharedBuffer(int capacity) {
7
        this.capacity = capacity;
8
    }
9

10
    // 생산자: 데이터 생성
11
    public synchronized void produce(int data) throws InterruptedException {
12
        while (buffer.size() == capacity) {
13
            wait();  // 버퍼가 가득 찼으면 대기
14
        }
15
        buffer.add(data);
16
        System.out.println("생산: " + data);
17
        notifyAll();  // 소비자 깨우기
18
    }
19

20
    // 소비자: 데이터 소비
21
    public synchronized int consume() throws InterruptedException {
22
        while (buffer.isEmpty()) {
23
            wait();  // 버퍼가 비었으면 대기
24
        }
25
        int data = buffer.poll();
26
        System.out.println("소비: " + data);
27
        notifyAll();  // 생산자 깨우기
28
        return data;
29
    }
30
}
31

32
// 생산자 스레드
33
class Producer extends Thread {
34
    private SharedBuffer buffer;
35

36
    public void run() {
37
        for (int i = 0; i < 10; i++) {
38
            try {
39
                buffer.produce(i);
40
                Thread.sleep(100);
41
            } catch (InterruptedException e) {
42
                e.printStackTrace();
43
            }
44
        }
45
    }
46
}
47

48
// 소비자 스레드
49
class Consumer extends Thread {
50
    private SharedBuffer buffer;
51

52
    public void run() {
53
        for (int i = 0; i < 10; i++) {
54
            try {
55
                buffer.consume();
56
                Thread.sleep(200);  // 생산자보다 느림
57
            } catch (InterruptedException e) {
58
                e.printStackTrace();
59
            }
60
        }
61
    }
62
}

1
char buffer[10];
2
strcpy(buffer, "This is a very long string");  // 버퍼 오버플로우!
3

4
// buffer[10]을 넘어서는 데이터가 인접 메모리를 덮어씀

1
// 안전한 방법 1: 크기 제한
2
strncpy(buffer, input, sizeof(buffer) - 1);
3
buffer[sizeof(buffer) - 1] = '\0';
4

5
// 안전한 방법 2: 경계 검사
6
if (strlen(input) < sizeof(buffer)) {
7
    strcpy(buffer, input);
8
}
9

10
// 안전한 방법 3: 안전한 함수 사용
11
strlcpy(buffer, input, sizeof(buffer));  // BSD 시스템

1
// 데이터베이스 조회 전 캐시 확인
2
public User getUserById(String userId) {
3
    // 1. 캐시 확인
4
    User user = redisTemplate.opsForValue().get("user:" + userId);
5

6
    if (user != null) {
7
        return user;  // 캐시 히트
8
    }
9

10
    // 2. 캐시 미스: DB 조회
11
    user = userRepository.findById(userId);
12

13
    // 3. 캐시에 저장 (TTL: 1시간)
14
    redisTemplate.opsForValue().set("user:" + userId, user, 1, TimeUnit.HOURS);
15

16
    return user;
17
}

1
사용자 (한국) → 오리진 서버 (미국)
2
  - 지연 시간: 200ms
3
  - 대역폭 비용: 높음
4

5
CDN 도입 후:
6
사용자 (한국) → CDN 엣지 서버 (서울)
7
  - 지연 시간: 10ms
8
  - 대역폭 비용: 낮음
9
  - 오리진 서버 부하 감소

1
// 버퍼링 없이 로그 작성 (느림)
2
public void logWithoutBuffer(String message) {
3
    fileWriter.write(message + "\n");
4
    fileWriter.flush();  // 매번 디스크 쓰기
5
}
6

7
// 버퍼링을 사용한 로그 작성 (빠름)
8
public class BufferedLogger {
9
    private BufferedWriter writer;
10
    private int bufferSize = 8192;  // 8KB 버퍼
11

12
    public void log(String message) throws IOException {
13
        writer.write(message + "\n");
14
        // 버퍼가 가득 차면 자동으로 flush
15
    }
16

17
    public void close() throws IOException {
18
        writer.flush();  // 남은 데이터를 디스크로
19
        writer.close();
20
    }
21
}

1
비디오 플레이어의 버퍼:
2

3
네트워크 ─────→ [재생 버퍼] ─────→ 화면
4
              (5-10초분)
5

6
동작:
7
1. 초기 버퍼링: 5초분 데이터 다운로드
8
2. 재생 시작
9
3. 재생하면서 계속 버퍼 채우기
10
4. 네트워크 느려지면: 버퍼의 데이터로 계속 재생
11
5. 버퍼 소진: "버퍼링 중..." 표시

1
// 버퍼 없이 개별 INSERT (느림)
2
for (User user : users) {
3
    jdbcTemplate.update("INSERT INTO users VALUES (?, ?)",
4
                        user.getId(), user.getName());
5
}
6
// 1,000개 INSERT → 10초
7

8
// 버퍼를 사용한 Batch INSERT (빠름)
9
jdbcTemplate.batchUpdate(
10
    "INSERT INTO users VALUES (?, ?)",
11
    new BatchPreparedStatementSetter() {
12
        public void setValues(PreparedStatement ps, int i) {
13
            ps.setString(1, users.get(i).getId());
14
            ps.setString(2, users.get(i).getName());
15
        }
16
        public int getBatchSize() {
17
            return users.size();
18
        }
19
    }
20
);
21
// 1,000개 INSERT → 1초

1
suspend fun getWithLock(key: String): String? {
2
    val cached = redis.opsForValue().get(key)
3
    if (cached != null) return cached
4

5
    val lockKey = "lock:$key"
6
    val lockValue = UUID.randomUUID().toString()
7
    val acquired = redis.opsForValue().setIfAbsent(lockKey, lockValue, 5, TimeUnit.SECONDS)
8

9
    if (acquired == true) {
10
        try {
11
            val data = database.query(...)
12
            redis.opsForValue().set(key, data, 1, TimeUnit.HOURS)
13
            return data
14
        } finally {
15
            // 락 해제 시 자신의 락인지 확인 (Lua 스크립트로 원자적 수행)
16
            val luaScript = """
17
                if redis.call('get', KEYS[1]) == ARGV[1] then
18
                    return redis.call('del', KEYS[1])
19
                else
20
                    return 0
21
                end
22
            """
23
            redis.execute(DefaultRedisScript<Long>(luaScript, Long::class.java), listOf(lockKey), lockValue)
24
        }
25
    } else {
26
        delay(100)
27
        return redis.opsForValue().get(key)
28
    }
29
}

1
fun getWithEarlyExpiration(key: String): String {
2
    val cached = redis.opsForValue().get(key)
3
    val ttl = redis.getExpire(key, TimeUnit.SECONDS)
4

5
    if (ttl < TTL * 0.1) {
6
        CoroutineScope(Dispatchers.IO).launch {
7
            val fresh = database.query(...)
8
            redis.opsForValue().set(key, fresh, TTL, TimeUnit.SECONDS)
9
        }
10
    }
11

12
    return cached ?: database.query(...)
13
}

1
// 조회수 증가: Redis에만 (빠름)
2
fun incrementViewCount(videoId: Long) {
3
    redis.opsForValue().increment("view:$videoId")
4
}
5

6
// 1분마다 MySQL에 동기화
7
@Scheduled(fixedRate = 60000)
8
fun syncViewCounts() {
9
    // redis.keys() 대신 SCAN 사용 (프로덕션 안전)
10
    val keys = mutableListOf<String>()
11
    var cursor = "0"
12
    do {
13
        val result = redis.scan(cursor, ScanOptions.scanOptions().match("view:*").count(100).build())
14
        keys.addAll(result.keys)
15
        cursor = result.cursorAsString
16
    } while (cursor != "0")
17

18
    // GETDEL 또는 Lua 스크립트로 읽기와 리셋을 원자적으로 수행해야 데이터 손실을 방지할 수 있다
19
    val luaScript = """
20
        local result = {}
21
        for i, key in ipairs(KEYS) do
22
            local value = redis.call('getdel', key)
23
            table.insert(result, value or '0')
24
        end
25
        return result
26
    """
27
    val counts = redis.execute(DefaultRedisScript<List<String>>(luaScript, List::class.java), keys)
28

29
    jdbcTemplate.batchUpdate(
30
        "UPDATE videos SET view_count = view_count + ? WHERE video_id = ?",
31
        // ... batch update using counts
32
    )
33
}

1
키 "user:1": hash = 12345
2
  Before: 12345 % 3 = 0 (서버 0)
3
  After:  12345 % 4 = 1 (서버 1)

1
Cache-Control: max-age=0, s-maxage=31536000

1
/v1234/main.js
2
/v1235/main.js

1
Cache-Control: max-age=31536000