자바 얕은 복사/깊은 복사 차이 - Arrays.copyOf를 어셈블리까지

먼저: 얕은 복사와 깊은 복사의 차이

• 얕은 복사(shallow copy): 배열만 새로 만들고, 그 안의 객체는 복사하지 않는다. 참조값만 복사되므로 복사본과 원본이 같은 객체를 가리킨다.

• 깊은 복사(deep copy): 배열 안의 객체까지 새로 만들어 복사한다. 복사본을 수정해도 원본에 영향이 없다.

Person[] original = { new Person("kim") };
Person[] copy = Arrays.copyOf(original, 1);

copy[0].setName("lee");
System.out.println(original[0].getName()); // "lee" — 원본도 바뀐다 (얕은 복사)

전체 호출 체인

ArrayList.add(E)
  → ArrayList.grow()
    → Arrays.copyOf(T[], int)
      → System.arraycopy(...)              // native 진입점
        → JVM_ArrayCopy (jvm.cpp)
          → ObjArrayKlass::copy_array
            → ArrayAccess::oop_arraycopy
              → Copy::conjoint_oops_atomic
                → pd_conjoint_oops_atomic   // oop* → jlong* 캐스팅
                  → _Copy_conjoint_jlongs_atomic  // 어셈블리 stub

1. 자바 레이어 — 객체를 새로 만들지 않음

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    T[] copy = ((Object)newType == (Object)Object[].class)
        ? (T[]) new Object[newLength]
        : (T[]) Array.newInstance(...);
    System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength));
    return copy;
}

@IntrinsicCandidate
public static native void arraycopy(Object src, int srcPos,
                                    Object dest, int destPos, int length);

2. HotSpot 진입 — 배열 타입에 따른 분기

arrayOop s = arrayOop(JNIHandles::resolve_non_null(src));
s->klass()->copy_array(s, src_pos, d, dst_pos, length, thread);

• Object[]로 생성된 배열의 klass는 ObjArrayKlass의 인스턴스 → ObjArrayKlass::copy_array

• int[]로 생성된 배열의 klass는 TypeArrayKlass의 인스턴스 → TypeArrayKlass::copy_array

3. 인덱스를 메모리 오프셋으로 변환

size_t src_offset = (size_t) objArrayOopDesc::obj_at_offset<oop>(src_pos);
size_t dst_offset = (size_t) objArrayOopDesc::obj_at_offset<oop>(dst_pos);

oop(Ordinary Object Pointer): HotSpot이 자바 객체를 가리킬 때 쓰는 포인터. 64비트 JVM에서는 8바이트다.

4. GC 배리어 — 객체 배열 경로에만 존재

bool oop_arraycopy_in_heap(...) {
    bs->write_ref_array_pre(dst_raw, length, false);   // pre-barrier
    Raw::oop_arraycopy(...);                            // 실제 비트 복사
    bs->write_ref_array((HeapWord*)dst_raw, length);    // post-barrier (카드 마킹)
}

(1) Pre-barrier

dst = [null, null, null, null, null, null, null, null, null, null, ...]

(2) 비트 복사

src = [str0, str1, str2, ..., str9]
        ↓     ↓     ↓            ↓
dst = [str0, str1, str2, ..., str9, null, null, null, null, null]

(3) Post-barrier

왜 post-barrier가 필요한가

비대칭이 보여주는 것

5. oop* → jlong* 캐스팅

static void pd_conjoint_oops_atomic(const oop* from, oop* to, size_t count) {
#ifdef AMD64
    assert(BytesPerLong == BytesPerOop, "jlongs and oops must be the same size");
    _Copy_conjoint_jlongs_atomic((const jlong*)from, (jlong*)to, count);
#endif
}

• oop*(객체 포인터 배열) → jlong*(8바이트 정수 배열)로 캐스팅

• 이후 호출되는 _Copy_conjoint_jlongs_atomic은 long[] 복사에 쓰이는 바로 그 함수

6. 어셈블리 stub — movq 두 줄

L_copy_8_bytes:
    movq rax, [from + qword_count*8 - 8]
    movq [to + qword_count*8 - 8], rax
    dec  qword_count
    jnz  L_copy_8_bytes

복사 결과

src[0] → 0x1010 → "hello" 객체 (힙)
dst[0] → null

src[0] → 0x1010 ─┐
                 ├──→ "hello" 객체 (힙, 그대로 1개)
dst[0] → 0x1010 ─┘

추가: 왜 이름이 memcpy가 아니라 "conjoint"인가

If the src and dest arguments refer to the same array object, then the copying is performed as if the components ... were first copied to a temporary array ... and then ... copied into positions ... of the destination array. — System.arraycopy Javadoc (Java SE 21)

정리

• Arrays.copyOf의 복사는 6단계의 호출 체인을 거쳐 어셈블리 movq 두 줄로 귀결된다.

• 객체 배열 복사 경로에만 GC 배리어가 붙으며, 이는 복사 대상이 참조값임을 보여준다.

• pd_conjoint_oops_atomic이 oop*를 jlong*로 캐스팅하는 시점부터 코드는 객체 주소를 단순한 8바이트 정수로 취급한다.

• 따라서 Arrays.copyOf의 복사는 얕은 복사다.