메모리 관리 & 복사

불변성(Immutability)이란?

• 객체의 상태가 생성된 이후로 변경되지 않는 성질
• 불변 객체는 생성 시점의 상태를 유지하며, 이후에는 그 상태를 변경할 수 없다.
• 객체의 필드 값이나 내부 데이터가 외부에서 수정될 수 없도록 보장한다.
• 프로그램의 예측 가능성과 안정성을 높이는 중요한 개념

불변성의 장점

• 스레드 안전성(Thread Safety)

  • 여러 스레드가 동시에 접근해도 상태가 변경되지 않으므로 안전
  • 별도의 동기화 메커니즘 없이도 스레드 안전성 보장
  
  

• 사이드 이펙트 방지

  • 메서드 호출이나 변수 전달 시 예상치 못한 상태 변경을 방지
  • 함수형 프로그래밍의 핵심 원칙
  
  

• 캐싱과 최적화

  • 객체의 해시코드를 한 번 계산한 후 재사용 가능
  • String Interning(ex. String Pool 활용)과 같은 메모리 최적화 기법 활용 가능

불변 객체 구현

• Java

  • String 클래스 (대표적인 불변 객체)

    String str1 = "Hello";
    String str2 = str1.concat(" World");
    
    System.out.println(str1);  *// "Hello" (원본 변경 없음)*
    System.out.println(str2);  *// "Hello World" (새로운 객체 생성)*
    

    • String 객체는 한 번 생성되면 내용을 변경할 수 없음
      • 변경 필요 시 Mutable String 클래스인 StringBuilder나 StringBuffer 활용
      • StringBuilder나 StringBuffer는 Thread-Safety의 차이
    • 문자열 조작 시 새로운 String 객체가 생성된다.
    
    
    

• JavaScript

  • Object.freeze()

    const person = Object.freeze({
        name: "John",
        age: 30
    });
    
    person.age = 31;  *// 무시됨 (strict mode에서는 에러)*
    console.log(person.age);  *// 30*
    

    
    

  • Immutable.js 라이브러리

    import { Map } from 'immutable';
    
    const map1 = Map({ a: 1, b: 2, c: 3 });
    const map2 = map1.set('b', 50);
    
    console.log(map1.get('b'));  *// 2 (원본 유지)*console.log(map2.get('b'));  *// 50 (새로운 객체)*
    

  
  
  

• Python

  • 문자열, 튜플, frozenset 등이 기본적으로 불변

    text = "Hello"
    new_text = text + " World"
    print(text)      # "Hello" (원본 유지)
    print(new_text)  # "Hello World" (새 객체)
    
    numbers = (1, 2, 3)  # 튜플은 불변
    # numbers[0] = 5     # 에러! 튜플은 변경 불가
    

  
  

  • namedtuple 사용

    from collections import namedtuple
    
    Point = namedtuple('Point', ['x', 'y'])
    p1 = Point(1, 2)
    p2 = p1._replace(x=5)  # 새 객체 생성
    
    print(p1)  # Point(x=1, y=2) (원본 유지)
    print(p2)  # Point(x=5, y=2) (새 객체)
    

  
  

  • dataclass(frozen=True)

    from dataclasses import dataclass
    
    @dataclass(frozen=True)
    class ImmutablePerson:
        name: str
        age: int
        
        def with_age(self, new_age):
            return ImmutablePerson(self.name, new_age)
    
    person = ImmutablePerson("Alice", 25)
    older_person = person.with_age(26)
    
    print(person.age)        # 25 (원본 유지)
    print(older_person.age)  # 26 (새 객체)
    
    # person.age = 30  # 에러!
    

    • @dataclass(frozen=True)로 불변 설정
    • 불변 객체(frozen 객체)는 변경 불가

실무에서의 활용

1. 클래스를 final로 선언
   • 상속을 통한 상태 변경 가능성 차단
2. 모든 필드를 private final로 선언
   • 외부에서 직접 접근 불가
   • 초기화 후 재할당 불가
3. Setter 메서드 제공하지 않음
   • 객체 생성 후 상태 변경 방법 차단
4. 가변 객체 필드의 방어적 복사
   • 생성자에서 입력받은 가변 객체 복사
   • Getter에서 내부 객체의 복사본 반환

• 쉽게 Lombok의 @Value 애노테이션으로 구현 가능

• 불변 클래스 직접 구현

  public final class ImmutablePerson {
  
      private final String name;
      private final int age;
      private final List<String> hobbies;
      
      public ImmutablePerson(String name, int age, List<String> hobbies) {
          this.name = name;
          this.age = age;
          *// 방어적 복사: 외부 컬렉션의 변경으로부터 보호*
          this.hobbies = Collections.unmodifiableList(new ArrayList<>(hobbies));
      }
      
      public String getName() { return name; }
      public int getAge() { return age; }
      
      public List<String> getHobbies() {
          *// 방어적 복사: 내부 상태 노출 방지*
          return new ArrayList<>(hobbies);
      }
  }
  

  • 클래스를 final로 선언하여 상속 방지
  • 모든 필드를 private final로 선언
  • Setter 메서드 제공하지 않음
  • 가변 객체 필드는 방어적 복사 사용

실무에서의 활용

• Value Object 패턴

  public final class Money {
      private final BigDecimal amount;
      private final String currency;
      
      public Money(BigDecimal amount, String currency) {
          this.amount = amount;
          this.currency = currency;
      }
      
      public Money add(Money other) {
          if (!this.currency.equals(other.currency)) {
              throw new IllegalArgumentException("Different currencies");
          }
          return new Money(this.amount.add(other.amount), this.currency);
      }
      
      *// equals, hashCode, toString 구현...*
  }
  

  • Value Object

    • 고유 식별자(ID)가 없고, 값 자체로 객체의 동일성을 판단하는 객체
    • 즉, 값이 같으면 같은 객체로 간주

  • DDD(Domain-Driven Design)의 패턴

  • 대개 Value Object는 불변이므로 연산 시 새로운 객체를 반환한다.

  • 이렇게 새로운 객체를 반환하는 이유는 불변성을 유지하고, 100원 + 50원이 150원이 되는 것이지, 100원이 150원으로 변하는 것이 아니라는 것을 보여줄 수 있다.

    즉, VO는 값을 나타내므로, 연산 결과는 새로운 값을 나타내야 한다.
  
  
  

• 불변 컬렉션

  public final class UserGroup {
      private final List<String> members;
      
      public UserGroup(List<String> members) {
          this.members = Collections.unmodifiableList(new ArrayList<>(members));
      }
      
      public UserGroup addMember(String member) {
          List<String> newMembers = new ArrayList<>(this.members);
          newMembers.add(member);
          return new UserGroup(newMembers);  // 새 객체 반환
      }
  }
  

불변성의 한계와 고려사항

• 메모리 사용량 증가

  • 객체 변경 시 새로운 객체 생성으로 인한 메모리 오버헤드
  • 특히 큰 객체나 빈번한 변경이 필요한 경우 성능 이슈 가능
  
  
  

• Builder 패턴 활용

  public final class ImmutableStudent {
      private final String name;
      private final int age;
      private final List<String> subjects;
      
      private ImmutableStudent(Builder builder) {
          this.name = builder.name;
          this.age = builder.age;
          this.subjects = Collections.unmodifiableList(new ArrayList<>(builder.subjects));
      }
      
      public static class Builder {
          private String name;
          private int age;
          private List<String> subjects = new ArrayList<>();
          
          public Builder setName(String name) {
              this.name = name;
              return this;
          }
          
          public Builder setAge(int age) {
              this.age = age;
              return this;
          }
          
          public Builder addSubject(String subject) {
              this.subjects.add(subject);
              return this;
          }
          
          public ImmutableStudent build() {
              return new ImmutableStudent(this);
          }
      }
  }
  

  import lombok.Builder;
  import lombok.Value;
  
  @Value  // 불변 객체 생성 (final, getter, equals/hashCode 자동)
  @Builder
  public class ImmutablePerson {
      String name;
      int age;
      String email;
      List<String> hobbies;
  }
  
  // 사용
  ImmutablePerson person = ImmutablePerson.builder()
      .name("홍길동")
      .age(30)
      .email("hong@example.com")
      .hobbies(Arrays.asList("독서", "영화"))
      .build();
  

  • 불변 객체는 생성 후 변경할 수 없지만, 생성할 때는 복잡할 수 있어서 Builder를 활용한다
  • Builder 클래스는 가변 객체지만, build() 호출 시 불변 객체를 만들어준다.
  • @Builder, @Value 애노테이션으로 불변 객체를 쉽게 정의할 수 있다.

메모리 최적화 기법

• 객체 풀링 (Object Pooling)

  • 재사용 가능한 객체들을 미리 생성해서 풀에 보관

• 지연 초기화 (Lazy Initialization)

  • 실제 필요할 때까지 객체 생성 미루기

• 플라이웨이트 패턴 (Flyweight Pattern)

  • 공통 데이터를 공유해서 메모리 절약

• WeakReference 사용

  • 가비지 컬렉션(GC)을 방해하지 않는 약한 참조

• String Interning

  • String Pool 활용

    (String Pool이란 JVM이 문자열 리터럴을 저장하는 특별한 메모리 영역)

• 캐싱

  • 계산 결과나 자주 사용되는 객체 재사용

함수형 프로그래밍

• 함수형 프로그래밍 (Functional Programming)

  • “무엇을 할 것인가”에 집중하는 방식

  • 함수형 프로그래밍의 핵심은 순수 함수로,

    • 같은 입력 ⇒ 같은 출력, 부작용(Side Effect) 없어야 한다.
    • 즉 결과가 이전 호출에 영향을 받지 않아야 한다. (예측 가능)

  • 순수하지 않은 함수

    class Calculator {
        private int total = 0;
        
        public int add(int value) {
            total += value;     // 외부 상태 변경 (부작용!)
            return total;       
        }
    }
    
    Calculator calc = new Calculator();
    System.out.println(calc.add(5));  // 5
    System.out.println(calc.add(5));  // 10
    

  • 순수 함수

    public class PureCalculator {
        public static int add(int current, int value) {
            return current + value;  // 외부 상태 변경 없음, 예측 가능
        }
    }
    
    System.out.println(PureCalculator.add(10, 5));  // 항상 15
    System.out.println(PureCalculator.add(10, 5));  // 항상 15
    

  
  

• 명령형 프로그래밍 (Imperative Programming)

  • 단계 별로 “어떻게 할 것인가”에 집중하는 방식

방어적 복사(Defensive Copying)란?

• 객체의 불변성과 캡슐화를 보장하기 위해 객체의 복사본을 생성하는 기법
• 외부에서 내부 상태를 직접 변경하는 것을 방지
• 주로 가변 객체(Mutable Object)를 다룰 때 사용
• 생성자와 접근자 메서드에서 주로 적용
  • 생성자 - 외부에서 전달된 가변 객체는 반드시 복사
  • 접근자 메서드 - 내부 가변 상태를 직접 반환하지 않는다.

방어적 복사가 필요한 이유

• 문제 상황 예시

  public class BadPeriod {
  
      private final Date start;
      private final Date end;
      
      public BadPeriod(Date start, Date end) {
          this.start = start;  // 위험: 참조 공유
          this.end = end;  // 위험: 참조 공유   
      }
      
      public Date getStart() { return start; } 
      public Date getEnd() { return end; }
  }
  
  // 문제 발생
  Date startDate = new Date();
  Date endDate = new Date(startDate.getTime() + 86400000); // 하루 후
  BadPeriod period = new BadPeriod(startDate, endDate);
  
  // 외부에서 내부 상태 변경 가능!
  startDate.setTime(0);              // 생성자 인수 변경
  period.getEnd().setTime(0);        // getter 반환값 변경
  

  • 방어적 복사가 없는 상황
  • 외부 코드가 객체의 내부 상태를 의도치 않게 변경

방어적 복사 구현

public class SafePeriod {

    private final Date start;
    private final Date end;
    
    public SafePeriod(Date start, Date end) {
        this.start = new Date(start.getTime());  // 생성자에서 방어적 복사
        this.end = new Date(end.getTime());
        
        // 유효성 검사는 복사 후에 수행
        if (this.start.compareTo(this.end) > 0) {
            throw new IllegalArgumentException("시작일이 종료일보다 늦습니다");
        }
    }
    
    public Date getStart() {  // 접근자에서 방어적 복사
        return new Date(start.getTime());
    }
    
    public Date getEnd() { return new Date(end.getTime()); }
}

// 안전한 사용
Date startDate = new Date();
Date endDate = new Date(startDate.getTime() + 86400000);
SafePeriod period = new SafePeriod(startDate, endDate);

startDate.setTime(0);              // 원본 변경해도 영향 없음
period.getEnd().setTime(0);        // 복사본 변경이므로 영향 없음

• 생성자와 getter 모두에서 방어적 복사 수행

  List<String> maliciousData = new ArrayList<>(Arrays.asList("normal"));
  SafeExample example = new SafeExample(maliciousData);
  
  maliciousData.add("attack1");  // 막힘 ✅
  
  List<String> leaked = example.getItems();
  leaked.add("attack2");  // 막힘 ✅ (복사본이므로)
  

  • 이렇게 양쪽 모두 막지 않는다면 다른 한쪽을 통해 변경할 수 있다.

• 외부에서 변경 시도해도 내부 상태는 안전

• 유효성 검사는 복사 후 수행

  • 복사 전 검사 시 TOCTOU 공격 가능

    public class VulnerableClass {
        private final List<String> items;
        
        public VulnerableClass(List<String> items) {
            // 1. 검사 (Check)
            if (items == null || items.isEmpty()) {
                throw new IllegalArgumentException("Items cannot be null or empty");
            }
            
            // 여기서 다른 스레드가 items를 변경할 수 있음! (시간차 공격)
            
            // 2. 사용 (Use) 
            this.items = new ArrayList<>(items);  // 변경된 데이터로 복사됨!
        }
    }
    

컬렉션에서의 방어적 복사

• List 방어적 복사

  public class StudentGroup {
      private final List<String> students;
  
      public StudentGroup(List<String> students) {
          this.students = new ArrayList<>(students); // 생성자에서 방어적 복사
      }
  
          public List<String> getStudentsReadOnly() {
                  return Collections.unmodifiableList(new ArrayList<>(students));
          }
          
          public StudentGroup addStudent(String student) {
          List<String> newStudents = new ArrayList<>(this.students);
          newStudents.add(student);
          return new StudentGroup(newStudents);
      }
  

  
  

• Map 방어적 복사

  public class Configuration {
      private final Map<String, String> properties;
      
      public Configuration(Map<String, String> properties) {
          // 방어적 복사 (얕은 복사)
          this.properties = new HashMap<>(properties);
      }
      
      public Map<String, String> getProperties() {
          // 불변 뷰로 반환 (복사 + 읽기 전용)
          return Collections.unmodifiableMap(new HashMap<>(properties));
      }
      
      ...
  }
  

  • Collections.unmodifiableMap()은 읽기 전용 래퍼로 추가 보호를 해준 것이다.

얕은 복사 vs 깊은 복사

• 얕은 복사 (Shallow Copy)

  public class ShallowCopyExample {
      private final List<List<String>> matrix;
      
      public ShallowCopyExample(List<List<String>> matrix) {
          // 얕은 복사 
          this.matrix = new ArrayList<>(matrix);
      }
      
      public List<List<String>> getMatrix() {
          return new ArrayList<>(matrix);  // 여전히 내부 리스트는 공유됨
      }
  }
  

  • 외부 리스트만 복사, 내부 리스트는 참조 공유

  • 문제 발생 가능

    List<String> row1 = new ArrayList<>(Arrays.asList("a", "b"));
    List<String> row2 = new ArrayList<>(Arrays.asList("c", "d"));
    List<List<String>> matrix = Arrays.asList(row1, row2);
    
    ShallowCopyExample example = new ShallowCopyExample(matrix);
    row1.add("modified");  // 내부 상태 변경됨!
    

  
  
  

• 깊은 복사 (Deep Copy)

  public class DeepCopyExample {
      private final List<List<String>> matrix;
      
      public DeepCopyExample(List<List<String>> matrix) {
          // 깊은 복사
          this.matrix = new ArrayList<>();
          for (List<String> row : matrix) {
              this.matrix.add(new ArrayList<>(row));
          }
      }
      
      public List<List<String>> getMatrix() {
          List<List<String>> copy = new ArrayList<>();
          for (List<String> row : matrix) {
              copy.add(new ArrayList<>(row));
          }
          return copy;
      }
  }
  

  • 모든 레벨의 객체를 복사

다양한 최적화 기법

• 방어적 복사

  public class PerformanceConsideration {
      private final byte[] largeData;
      
      public byte[] getData() {
          return largeData.clone();
      }
  

  • clone()은 얕은 복사 메서드 (원시 타입의 경우 완전한 복사)
  • 안전하지만 비용 높음
  
  
  

• 읽기 전용 뷰 (방어적 뷰)

  public class PerformanceConsideration {
      private final byte[] largeData;
      
      ...
      
      public ByteBuffer getDataAsReadOnly() {
          return ByteBuffer.wrap(largeData).asReadOnlyBuffer();
      }
  }
  

  • 복사하지 않고 원본 데이터를 래핑만 한다.
  • 메모리 절약
  
  
  

• 지연 복사 (Lazy Copying)

  public class LazyCopyExample {
      private final List<String> originalData;
      private List<String> cachedCopy;
      
      public LazyCopyExample(List<String> data) {
          this.originalData = new ArrayList<>(data);
      }
      
      public List<String> getData() {
          if (cachedCopy == null) {
              cachedCopy = Collections.unmodifiableList(new ArrayList<>(originalData));
          }
          return cachedCopy;
      }
  }
  

  • 캐싱 최적화
    • 첫 호출 시에만 복사 작업 수행, 이후엔 캐시된 결과 재사용
  • 실제 필요할 때까지 복사를 미루는 최적화 기법