Swift 공식 문서 정리 - 메모리 안전성 (Memory Safety)

안녕하세요. 오늘은 Swift 프로그래밍에서 중요하지만 종종 간과되는 개념인 '메모리 안전성(Memory Safety)'에 대해 알아보겠습니다. 메모리 안전성을 이해하면 더 안정적이고 예측 가능한 코드를 작성할 수 있으며, 컴파일 타임과 런타임 오류를 방지할 수 있습니다.

📌 Swift의 메모리 안전성이란?

Swift는 기본적으로 코드에서 발생할 수 있는 안전하지 않은 동작을 방지하도록 설계되었습니다. 예를 들어:

• 변수가 사용되기 전에 초기화되는지 확인
• 메모리가 해제된 후에는 접근하지 않도록 보장
• 배열 인덱스가 범위를 벗어나지 않는지 검사

그리고 가장 중요하게, Swift는 메모리의 동일한 위치에 대한 다중 접근이 충돌하지 않도록 보장합니다. 이것이 오늘 중점적으로 살펴볼 내용입니다.

📌 메모리 접근 충돌 이해하기

메모리에 접근하는 것은 변수의 값을 읽거나 쓸 때 발생합니다:

// one에 저장된 메모리에 쓰기 접근
var one = 1

// one에 저장된 메모리에서 읽기 접근
print("We're number \(one)!")

메모리 접근 충돌은 코드의 서로 다른 부분이 동시에 동일한 메모리 위치에 접근할 때 발생합니다. 이러한 충돌은 예측할 수 없는 결과를 초래할 수 있습니다.

실생활 비유: 종이에 쓰여진 예산표를 업데이트하는 과정을 생각해보세요. 새 항목을 추가하는 도중에는 총액이 일시적으로 맞지 않게 됩니다. 이 시점에 누군가 총액을 보면 잘못된 정보를 얻게 됩니다.

📌 메모리 접근의 세 가지 특성

메모리 접근 충돌을 이해하려면 세 가지 주요 특성을 고려해야 합니다:

1. 접근 종류: 읽기 접근인지 쓰기 접근인지
2. 메모리 위치: 어떤 변수, 상수, 또는 프로퍼티에 접근하는지
3. 접근 기간: 즉각적인(instantaneous) 접근인지 장기(long-term) 접근인지

메모리 접근 충돌은 다음 조건을 모두 만족할 때 발생합니다:

• 적어도 하나의 접근이 쓰기 접근이다
• 동일한 메모리 위치에 접근한다
• 접근 기간이 겹친다

즉각적 접근과 장기 접근

대부분의 메모리 접근은 즉각적입니다. 즉, 접근이 시작되고 완료되는 사이에 다른 코드가 실행될 수 없습니다:

func oneMore(than number: Int) -> Int {
    return number + 1
}

var myNumber = 1
myNumber = oneMore(than: myNumber)
print(myNumber) // "2" 출력

하지만 장기 접근은 접근이 시작되고 완료되기 전에 다른 코드가 실행될 수 있습니다. 이러한 장기 접근은 주로:

• 함수와 메서드의 in-out 파라미터
• 구조체의 mutating 메서드

에서 발생합니다.

📌 in-out 파라미터의 충돌 접근

함수는 모든 in-out 파라미터에 장기 쓰기 접근을 합니다. 이 접근은 함수 호출이 시작될 때 시작되어 함수가 반환될 때까지 지속됩니다.

예제 1: in-out 파라미터와 전역 변수 충돌

var stepSize = 1

func increment(_ number: inout Int) {
    number += stepSize  // stepSize 읽기
}

increment(&stepSize)  // 오류: stepSize에 충돌 접근

이 코드는 오류가 발생합니다. increment(&stepSize)를 호출하면:

1. stepSize에 대한 장기 쓰기 접근이 시작됩니다(number가 stepSize를 참조)
2. 함수 내부에서 stepSize의 값을 읽으려고 시도합니다
3. 이때 동일한 메모리 위치에 대한 읽기와 쓰기 접근이 겹쳐 충돌이 발생합니다

해결책: 명시적인 복사본 만들기

// 명시적 복사본 생성
var copyOfStepSize = stepSize
increment(&copyOfStepSize)

// 원본 업데이트
stepSize = copyOfStepSize
// stepSize는 이제 2입니다

예제 2: 여러 in-out 파라미터 충돌

func balance(_ x: inout Int, _ y: inout Int) {
    let sum = x + y
    x = sum / 2
    y = sum - x
}

var playerOneScore = 42
var playerTwoScore = 30
balance(&playerOneScore, &playerTwoScore)  // OK

balance(&playerOneScore, &playerOneScore)
// 오류: playerOneScore에 충돌 접근

동일한 변수를 여러 in-out 파라미터에 전달하면 동일한 메모리에 대한 여러 쓰기 접근이 발생하므로 충돌이 발생합니다.

📌 메서드에서 self에 대한 충돌 접근

구조체의 mutating 메서드는 메서드 호출 기간 동안 self에 대한 쓰기 접근을 수행합니다.

struct Player {
    var name: String
    var health: Int
    var energy: Int

    static let maxHealth = 10
    mutating func restoreHealth() {
        health = Player.maxHealth
    }
}

이 상황에서도 충돌이 발생할 수 있습니다:

extension Player {
    mutating func shareHealth(with teammate: inout Player) {
        balance(&teammate.health, &health)
    }
}

var oscar = Player(name: "Oscar", health: 10, energy: 10)
var maria = Player(name: "Maria", health: 5, energy: 10)
oscar.shareHealth(with: &maria)  // OK

oscar.shareHealth(with: &oscar)
// 오류: oscar에 충돌 접근

두 번째 호출에서 충돌이 발생하는 이유:

1. mutating 메서드는 self(oscar)에 대한 쓰기 접근을 수행합니다
2. in-out 파라미터 teammate도 동일한 oscar 인스턴스에 대한 쓰기 접근을 수행합니다
3. 동일한 메모리 위치에 대한 두 쓰기 접근이 겹쳐 충돌이 발생합니다

📌 프로퍼티에 대한 충돌 접근

값 타입(구조체, 튜플, 열거형)에서는 값의 일부분을 변경하면 전체 값이 변경됩니다. 이는 특정 프로퍼티에 접근하면 전체 값에 접근해야 함을 의미합니다.

var playerInformation = (health: 10, energy: 20)
balance(&playerInformation.health, &playerInformation.energy)
// 오류: playerInformation의 프로퍼티에 충돌 접근

var holly = Player(name: "Holly", health: 10, energy: 10)
balance(&holly.health, &holly.energy)  // 오류

그러나 컴파일러가 안전성을 증명할 수 있다면 접근을 허용합니다:

func someFunction() {
    var oscar = Player(name: "Oscar", health: 10, energy: 10)
    balance(&oscar.health, &oscar.energy)  // OK
}

위 예제에서는 다음 조건이 충족되어 안전한 접근으로 판단됩니다:

1. 인스턴스의 저장 프로퍼티만 접근함(계산 프로퍼티나 클래스 프로퍼티 아님)
2. 구조체가 지역 변수의 값임(전역 변수 아님)
3. 구조체가 클로저에 캡처되지 않거나 non-escaping 클로저에만 캡처됨

📌 안전한 코드 작성을 위한 팁

메모리 안전성 충돌을 피하기 위한 몇 가지 지침:

1. 변수의 범위 제한하기: 전역 변수보다 지역 변수를 선호하세요
2. 명시적인 복사본 사용하기: 동일한 변수에 여러 번 접근해야 할 때는 복사본을 만드세요
3. in-out 파라미터 사용 시 주의하기: 동일한 변수를 여러 in-out 파라미터에 전달하지 마세요
4. 값 타입의 프로퍼티에 대한 동시 접근 피하기: 특히 전역 변수나 escaping 클로저와 함께 사용할 때 주의하세요
5. mutating 메서드 내에서 self에 대한 참조 주의하기: 특히 다른 인스턴스와 상호작용할 때 확인하세요

📌 메모리 안전성과 성능 사이의 균형

Swift의 메모리 안전성 규칙은 코드의 안정성을 높이지만, 때로는 과도하게 제한적으로 느껴질 수 있습니다. 컴파일러가 메모리 안전성을 증명할 수 없는 경우에도 실제로는 안전한 코드가 있을 수 있습니다.

Swift의 메모리 안전성 강제는 절충안입니다:

• 메모리 배타적 접근(exclusive access): 더 엄격한 요구사항
• 메모리 안전성(memory safety): 배타적 접근보다 덜 엄격함

컴파일러가 안전하다고 증명할 수 있는 경우에는 더 유연한 접근을 허용합니다. 이러한 균형은 시간이 지남에 따라 컴파일러가 더 많은 패턴을 안전하다고 인식하면서 계속 발전할 것입니다.

📌 정리

Swift의 메모리 안전성 메커니즘은 코드의 안정성과 예측 가능성을 높이는 중요한 기능입니다. 주요 개념을 정리하면:

1. 메모리 접근 충돌은 동일한 메모리 위치에 대한 동시 접근에서 발생합니다
2. 충돌이 발생하려면 적어도 하나의 쓰기 접근이 있어야 하며, 동일한 메모리에 접근하고, 접근 기간이 겹쳐야 합니다
3. 장기 접근은 주로 in-out 파라미터와 mutating 메서드에서 발생합니다
4. 값 타입의 프로퍼티 접근은 전체 값에 대한 접근으로 간주됩니다
5. 컴파일러가 안전하다고 증명할 수 있는 경우에는 더 유연한 접근이 허용됩니다