shine의 개발 노트

[Rider] 여러 개의 프로젝트를 동시에 실행하는 방법

shine94 — Wed, 3 Dec 2025 14:54:57 +0900

1. 실행/디버그 구성 편집

[방법 1] 실행 버튼 드롭다운 > 목록 하단의 구성 편집 선택

[방법 2] 상단 메뉴 실행 > 구성 편집 선택

2. 복합 실행 구성 추가

실행/디버그 구성 창에서 + 버튼 > 복합 선택

3. 복합 실행 구성 설정

이름 설정 > + 버튼을 눌러 함께 실행할 프로젝트 추가 > 확인

[MMORPG 게임 개발(C#, Unity)] Part 4. 네트워크 프로그래밍

shine94 — Fri, 10 Oct 2025 01:11:31 +0900

* 해당 글은 게임 프로그래머 입문 올인원 강의를 보고 정리한 글입니다

https://www.inflearn.com/roadmaps/355#introduce

MMORPG 게임 개발, 켠김에 끝판왕까지! (유니티 + C#) 로드맵 - 인프런

C#, Unity 스킬을 학습할 수 있는 게임 개발 로드맵을 인프런에서 만나보세요.

www.inflearn.com

* 소켓 프로그래밍

(1) Listener 소켓 준비

(2) Bind (서버 주소/Port를 소켓에 연동)

(3) Listen

(4) Accept

* TCP

전송 순서가 보장된다

분실이 일어나면 책임지고 다시 전송한다 → 신뢰성이 좋다

전송할 상황이 아니면 일부만 보낸다(흐름/혼잡 제어)

고려할 것이 많다보니 속도는 UDP보다 느리다

* UDP

연결이라는 개념이 없다

분실에 대한 책임이 없다 → 신뢰성이 나쁘다

전송 순서가 보장되지 않는다

단순하기 때문에 속도는 TCP보다 빠르다

[헤드퍼스트 C#] Chapter 5. 데이터 기밀 유지하기

shine94 — Mon, 7 Jul 2025 08:55:01 +0900

* 해당 글은 시작하세요! 헤드퍼스트 C# 도서를 읽고 정리한 글입니다.

https://product.kyobobook.co.kr/detail/S000211338172

헤드 퍼스트 C# | 앤드류 스텔만 - 교보문고

헤드 퍼스트 C# | 상상을 초월하는 객체지향 C# 학습법 직관적인 설명과 다채로운 구성으로 생생하게 체험하는 C# 프로그래밍재치 넘치는 설명과 틀에 박히지 않은 구성으로 복잡한 개념도 쉽게

product.kyobobook.co.kr

https://github.com/head-first-csharp/fourth-edition

GitHub - head-first-csharp/fourth-edition: Code and graphics for the projects in the 4th edition of Head First C#

Code and graphics for the projects in the 4th edition of Head First C# - head-first-csharp/fourth-edition

github.com

* 캡슐화(encapsulation)

다른 클래스가 의도와는 다르게 값을 변경하거나

다른 클래스의 멤버를 잘못 사용하는 상황을 방지해서 코드를 안전하게 지켜준다

* 속성(property)

사용할 때는 필드처럼 보이고 내부 실행은 메서드처럼 작동하는 클래스 멤버이다

* 문자열 보간(string interpolation)

문자열 결합을 더 읽기 쉽게 해준다

이 기능을 사용하려면 문자열 앞에 $ 기호를 붙인 다음 중괄호 안에 출력할 값을 넣으면 된다

* 클래스의 모든 메서드는 유일한 시그니처(signature)를 가진다

* 객체 이니셜라이저에서 속성을 초기화할 수 있다

* 개발자가 정의하지 않아도 모든 클래스에는 생성자가 있다

* private 생성자를 추가해서 다른 클래스가 클래스를 인스턴스화하는 것을 막을 수 있다

[Unity] 벡터의 내적(Dot Product)

shine94 — Thu, 3 Jul 2025 15:11:09 +0900

https://www.youtube.com/watch?v=4-76jesTq2I

* 이 블로그는 두 벡터가 모두 정규화(normalized)된 경우, 즉 길이가 1인 단위 벡터일 때의 내적 결과를 기준으로 한다
ㄴ 일반적인 벡터끼리의 내적은 a · b = |a| * |b| * cos(θ)이다
ㄴ 따라서 벡터 길이가 1일 때만 내적 값이 -1 ~ 1 사이가 된다

* 벡터의 내적(Dot Product)

두 방향 벡터가 얼마나 같은 방향을 향하고 있는지를 숫자로 표현해주는 도구이다

두 벡터가 같은 방향일 수록 1에 가까워지고, 반대일수록 -1에 가까워진다

각도(θ)	내적 값(dot)	방향 관계 설명
0°	1.0	완전히 같은 방향
90°	0.0	수직(측면)
180°	-1.0	완전히 반대 방향

* 내적은 벡터의 길이가 아닌, 두 방향이 얼마나 유사한지를 수치로 판단하는 도구임을 명심하자!!

[예를 들어, 거리를 구하고 싶다면]

두 위치 백터의 차를 구하면, 방향 벡터를 얻을 수 있다

(이 벡터는 거리와 방향 정보를 모두 포함하고 있다)

구한 거리의 벡터의 크기(magnitude)를 구하면 두 위치 간의 실제 거리이고,

구한 거리의 벡터를 정규화(normalized vector)하면 방향만 남긴 단위 벡터가 된다

* transform.forward

길이가 1인 단위 벡터(normalized vector)

* magnitude는 항상 양수이고, 방향은 부호를 가진다

* 실제 사용 예제

Vector3 toTarget = (target.position - transform.position).normalized;
float dot = Vector3.Dot(transform.forward, toTarget);
if (dot > 0.7f)
    Debug.Log("바라보고 있음");

[Unity] 사인 곡선을 활용한 진동 표현 이해하기

shine94 — Tue, 1 Jul 2025 20:33:44 +0900

* 진동

어떤 물체가 중심값을 기준으로 좌우 또는 위아래로 반복적으로 움직이는 현상을 의미한다

[유니티에서 진동은 언제 쓰일까?]

오브젝트 좌우로 흔들기

ㄴ x = base + sin(theta)

위아래로 둥둥 뜨게 하기

ㄴ y = base + sin(theta)

크기나 색 등을 부드럽게 바꾸기

ㄴ scale = 1 + sin(theta) * 0.2f

* delta(델타)

변화량

수학, 물리, 프로그래밍에서 델타는 값이 얼마나 변했는지(차이)를 뜻한다

변화된 값 또는 이전 값과의 차이를 의미하는 접두어로 많이 사용한다

[예]

deltaTime

시간의 변화량, 한 프레임 동안 흐른 시간(초)

deltaPosition

위치의 변화량

deltaAngle

회전각의 변화량

* 왜 삼각함수가 진동과 연관이 있을까?

sin, cos는 삼각형에서 시작했지만, 원 위에서 점이 움직이는 패턴이다

시간에 따라

sin(θ) → 아래에서 시작 → 올라갔다 내려가고를 반복

cos(θ) → 위에서 시작 → 내려갔다가 올라가고를 반복

[그럼 탄젠트는!?]

tan(θ) = sin(θ) / cos(θ)

기울기(= 기울어진 정도)를 나타내며, 진동 표현에는 일반적으로 사용되지 않는다

회전각, 시야 각도 계산, 카메라 시선 처리 등에 더 많이 쓰인다

(+) tan(θ)는 π/2와 같은 특정 각도에서 값이 무한대로 발산하기 때문에, 진동 표현에는 부적합하다

* 탄젠트와 사인과 코사인의 차이는 명확한데 사인과 코사인은 헷갈린다!

둘 다 주기 함수고 -1 ~ 1 사이의 값을 주기적으로 반복한다

둘 다 진동 구현에 똑같이 쓸 수 있다

[차이점은 위상 차이다(phase difference)]

사인은 0에서 시작해서 위로 올라가고

코사인은 1에서 시작해서 내려간다

θ	sin(θ)	cos(θ)
0	0	1
π/2	1	0
π	0	-1
3π/2	-1	0
2π	0	1

[따라서]

사인과 코사인은 본질적으로 동일한 형태의 함수이며, 단지 시작 시점(위상)이 다르다

크게 다르다라고 느껴질 상황은 거의 없고 동일한 진동 기능을 수행할 수 있다

[그래도 굳이 실전에서 차이를 느끼고 싶다면......?]

(1) 움직임의 시작 위치를 명확하게 연출할 때

등장하자마자 위에서부터 떨어져야 한다면 → 코사인

중앙에서 부드럽게 시작해야 한다면 → 사인

이럴 때는 시각적으로 차이가 느껴질 수 있다

(2) 두 개의 파형(시간에 따라 값이 변화하는 모양)을 조합해서 움직임을 만들 때

사인과 코사인을 함께 쓸 때는 위상 차이가 움직임에 영향을 준다

하지만 단독으로 진동만 구현할 때는 거의 차이가 없다

[멋쟁이사자처럼부트캠프] 유니티 게임 개발 5기(2025.06.23-2025.06.27)

shine94 — Mon, 30 Jun 2025 05:39:09 +0900

* 해당 글은 유니티 게임 개발 수업 후 정리한 글입니다

https://bootcamp.likelion.net/school/kdt-ugm-5th

유니티 게임 개발 5기 : 멋사 부트캠프

개발부터 출시까지! 나만의 게임을 세상에 선보이는 유니티 부트캠프

bootcamp.likelion.net

* Update()

일반적인 작업용

이동 작업을 transform으로 직접 조작할 경우 여기서 처리하나,

이 방식은 프레임 스킵이 발생하면 그만큼 렌더링이 지연되어 지연되고,

지연된 만큼 한 번에 이동되기 때문에 순간이동처럼 보일 수 있다

또, transform으로 이동하는 경우, 물리 엔진을 거치지 않아 충돌 감지가 발생하지 않는다

[ 그럼 여기서 물리엔진 계산하면 되잖아]

물리 엔진은 고정된 시간 간격(Fixed Timestep)으로 계산된다

대부분 Update 속도가 훨씬 빠르며,

프레임마다 속도를 갱신하지만, 물리 엔진이 아직 계산을 반영하기 전 상태에서 덮어쓰게 되므로

이로 인해 이동 타이밍과 충돌 판정 타이밍이 엇갈리면서, 불안정한 움직임, 충돌 처리 누락, 끊김 등이 발생할 수 있다

* FixedUpdate()

물리 연산 작업용

Rigidbody를 이용한 물리 기반 작업은 여기서 처리하지 않으면 연산 타이밍이 꼬일 수 있다

[❓ Why]

물리 엔진은 고정된 시간 간격으로 계산하기 때문이다

* 최종적인 결론

입력은 Update에서

물리 엔진을 이용한 이동은 FixedUpdate에서

float input;

void Update()
{
	// 입력은 Update에서
	input = Input.GetAxisRaw("Horizontal");
}

void FixedUpdate()
{
	// 이동은 FixedUpdate에서
	rb.velocity = new Vector2(input * speed, rb.velocity.y);
}

* 타일맵(Tilemap)

이미지를 작은 타일로 나눠 격자 형태로 배치해서, 큰 배경이나 맵을 효율적으로 구성하는 방식

큰 배경 이미지를 통째로 가져가면 메모리 부담이 크지만,

작은 이미지를 반복해서 배치하면 동일한 리소스를 재사용하게 되므로 빌드 용량이 훨씬 가벼워진다

그 결과, 컴파일과 빌드 시간도 줄일 수 있다

* 타일 팔레트(Tile Palette)

타일맵 작업을 위해, 타일 이미지를 마치 물감을 팔레트에 올려두듯 정리해 놓는 도구

필요한 타일을 여기서 선택해서 씬에 배치할 수 있도록 도와준다

Window > 2D > Tile Palette

* Tilemap Collider 2D

타일맵마다 개별적인 Collider를 자동 생성해주는 컨포넌트

타일 하나마다 Collider가 생성되므로 경계선이 많아지고, 그로 인해 물리 연산이 비효율적이다

* Composite Collider 2D

여러 개의 Collider를 하나의 커다란 콜라이더로 합쳐주는 최적화 도구

성능 향상과 충돌 경계 단순화를 위해 자주 사용되며, Tilemap Collider 2D와 함께 쓰인다

[Edge Radius]

Collider 외곽선의 가장자리를 부드럽게 둥글리는 정도를 나타낸다

값이 클수록 둥글게 처리되어, 이동 가능한 영역이 그만큼 줄어든다

* Rigidbody 2D(Static 설정)

정적인 지형용으로 적절한 설정이며, 물리 시뮬레이션 전에 Collider를 미리 생성해두는 방식

즉, 런타임 중에 계산하지 않고, 씬 실행 시점에 이미 계산돼 있어서 성능에 유리하다

Composite Collider를 쓰려면 반드시 Rigidbody 2D가 필요하며, 이때는 Static 설정을 쓰는 게 일반적이다

* 지금 공부하고 있는 방식은 상하좌우 이동만 가능한 2D 캐릭터 조작 게임으로, 중력이나 회전이 필요하지 않음

[따라서]

물리 엔진에서 중력을 0으로, Freeze Rotation의 Z축을 체크하여 안정적인 이동 구현 가능

[만약 중력과 회전이 있다면]

중력에 의해 콜라이더의 둥근 곡면을 따라 미끄러지거나, 충돌 시 회전이 발생해 구르는 듯한 동작이 나타난다

둥근 곡면이 없더라도 충돌 시 물리 회전이 적용되어 기울어지거나 옆으로 눕는다

* 유니티의 UI 이벤트 시스템 인터페이스

UI 오브젝트나 Collider가 붙은 GameObject에서만 이벤트가 발생하며,

반드시 EventSystem과 Raycaster 구성 필요

[정리]

UI 오브젝트인 경우

- EventSystem

- Canvas + GraphicRaycaster

Collider가 붙은 GameObject(2D 기준)

- EventSystem

- Physics2DRaycaster

(1) IPointerDownHandler

마우스 버튼 또는 터치가 눌렸을 때 호출됨

void OnPointerDown(PointerEventData eventData)

(2) IDragHandler

마우스 또는 터치를 누르고 움직일 때(= 드래그) 호출됨

void OnDrag(PointerEventData eventData)

(3) IPointerUpHandler

마우스 버튼 또는 터치가 떼어졌을 때 호출됨

void OnPointerUp(PointerEventData eventData)

* 조이스틱 방향 벡터 코드

// direction1(방향 + 거리 포함) → 정규화 안된 상태
var dragDirection = _currPosition - _startPosition;

https://shine94.tistory.com/462

[Unity] 수학과 Unity 관점에서 벡터와 스칼라 정리

* 수학에서의 백터와 스칼라 (1) 스칼라(Scalar) 크기만 갖는 값 (예) 5m, 섭씨 20도, 256바이트, 4000 칼로리 (2) 벡터(Vector) 크기 + 방향을 갖는 값 (예) 30m/초 동쪽, 약 5마일 북쪽, 힘, 가속도 [정리하자면

shine94.tistory.com

* magnitude

벡터의 길이(방향은 무시됨)

* normalized

방향만 유지하고 길이를 1로 만든 벡터

* 조이스틱 드래그 방향 처리 코드

public void OnPointerDown(PointerEventData eventData)
{
    _startPosition = eventData.position;
}

public void OnDrag(PointerEventData eventData)
{
    _currPosition = eventData.position;
    var dragDirection = _currPosition - _startPosition;

    // distance : 거리
    // +75f, -75f : X/Y축 조이스틱 입력의 최대값(조이스틱 범위 제한)
    var maxDistance = Mathf.Min(dragDirection.magnitude, 75f);

    // _startPosition : 조이스틱 원래 위치
    // dragDirection.normalized * maxDistance : 드래그 방향값 * 최대 거리 75f
    handlerUI.transform.position = _startPosition + dragDirection.normalized * maxDistance;
}

public void OnPointerUp(PointerEventData eventData)
{
    // 드래그 종료 시 조이스틱 핸들 위치 초기화
    handlerUI.transform.position = Vector2.zero;
}

* 조이스틱 UI 구성 및 설정 경로

Canvas > Joystick(빈 오브젝트) > Background(조이스틱 배경) > Handle(방향 표시 이미지)

ㄴ Joystick(빈 오브젝트)의 Image 컴포넌트는 투명도 0으로 설정해야 함

* ForceMode2D

(1) Force

지속적으로 작용하는 힘(Continuous Force)

FixedUpdate마다 누적 적용되어 속도를 점점 증가시키는 가속도

(예) 바람, 물살처럼 꾸준히 밀어내는 힘

rigidbody2D.AddForce(Vector2.right * 10f, ForceMode2D.Force);

이 경우, FixedUpdate마다 10만큼의 가속도가 누적되어 점점 빨라진다

(2) Impulse

순간적인 충격(Instantaneous Impulse)

한 순간에 속도를 즉시 변화시키는 힘

점프, 충돌, 폭발처럼 짧고 강한 충격을 줄 때 사용

rigidbody2D.AddForce(Vector2.up * 10f, ForceMode2D.Impulse);

이 경우, 한 번만 힘이 적용되며 질량에 따라 속도 변화량이 결정된다

FixedUpdate 마다 반복 적용되지 않고, 딱 한 번 즉시 작용된다

* 애니메이션 블렌딩 시 실수했던 점

처음에 2D Simple Directional을 선택했는데, 이 블렌드 타입은 방향 값이 180도 이상인 경우를 처리할 수 없다

수업에서 사용했던 방향 값(예: -1, 0, 1)처럼 양방향 입력이 필요한 경우에는 2D Freeform Directional을 선택해야 했다

* AudioSound

동시에 여러 개의 사운드를 재생할 수 없기 때문에, 효과음을 겹쳐 재생하려면 각각 AudioSound가 필요하다

ㄴ 소리를 중첩시킬 때, 애니메이션의 이벤트와 연결하여 트리거로 활용하기도 한다

* Time.timeScale(영상 재생 시 배속 조절과 유사한 개념)

유니티의 시간의 흐름 속도를 조절할 수 있는 속성이다

기본 값은 1f이며, 이는 정상적인 시간 흐름이다

값을 0f으로 설정하면 시간이 완전히 정지되며, 애니메이션, 이동, 물리 처리 등 모두 멈춘다

[Unity] 수학과 Unity 관점에서 벡터와 스칼라 정리

shine94 — Sat, 28 Jun 2025 23:50:25 +0900

* 수학에서의 백터와 스칼라

(1) 스칼라(Scalar)

크기만 갖는 값

(예) 5m, 섭씨 20도, 256바이트, 4000 칼로리

(2) 벡터(Vector)

크기 + 방향을 갖는 값

(예) 30m/초 동쪽, 약 5마일 북쪽, 힘, 가속도

[정리하자면]

핵심 차이는 방향의 존재 여부다

* 유니티에서의 Vector3

유니티의 Vector3 구조체는 수학적 벡터 개념을 기반으로 한 자료형이지만,

실제 의미는 어떻게 사용하느냐에 따라 달라진다

// 위치
transform.position = new Vector3(0, 3, 0);

// 방향(this → target)
Vector3 direction1 = target.position - transform.position;		// 두 위치 차이 벡터
Vector3 direction2 = (target.position - transform.position).normalized;	// 길이를 1로 만들어, 방향만 남긴 단위 벡터(normalized vector)

// 속도 또는 힘의 방향과 크기를 적용할 때(반드시 방향 벡터를 정규화해서 사용)
rigidbody.velocity = direction2 * 3f;
rigidbody.AddForce(direction2 * force);

direction1(이동 벡터)

방향 + 시작 위치로부터의 거리

이동해야 할 거리(크기)가 중요한 경우

(예) 목표까지 얼마나 멀리 가야하는지를 중요한 경우, 총알이 목표물까지 날아가는 방향과 거리

direction2(방향 벡터)

방향만

정규화된 단위 벡터(길이 1)

(예) 어디로 향해야 하는지만 중요한 경우, 캐릭터가 어느 방향을 바라보는가

* 참고한 문서들

https://www.physicsclassroom.com/class/1dkin/lesson-1/scalars-and-vectors?utm_source=chatgpt.com

Scalars and Vectors

Scalars and Vectors Hold down the T key for 3 seconds to activate the audio accessibility mode, at which point you can click the K key to pause and resume audio. Useful for the Check Your Understanding and See Answers. Physics is a mathematical science. Th

www.physicsclassroom.com

https://mathinsight.org/vector_introduction?utm_source=chatgpt.com

An introduction to vectors - Math Insight

Definition of a vector A vector is an object that has both a magnitude and a direction. Geometrically, we can picture a vector as a directed line segment, whose length is the magnitude of the vector and with an arrow indicating the direction. The direction

mathinsight.org

https://docs.unity3d.com/ScriptReference/Vector3-normalized.html?utm_source=chatgpt.com

[멋쟁이사자처럼부트캠프] 유니티 게임 개발 5기(2025.06.16-2025.06.19)

shine94 — Fri, 27 Jun 2025 19:28:44 +0900

* 해당 글은 유니티 게임 개발 수업 후 정리한 글입니다

https://bootcamp.likelion.net/school/kdt-ugm-5th

유니티 게임 개발 5기 : 멋사 부트캠프

개발부터 출시까지! 나만의 게임을 세상에 선보이는 유니티 부트캠프

bootcamp.likelion.net

* 형 변환(Type Casting)

다른 데이터 타입으로 변환하는 것

* 객체지향 프로그래밍(OOP, Object-Oriented Programming)

객체(데이터 + 동작) 단위로 프로그램을 구성하는 방식

캡슐화, 상속, 다형성, 추상화가 핵심 개념

* 오버로딩(Overloading)

같은 이름의 메서드를 매개변수만 다르게 여러 개 정의하는 것

* 상속(Inheritance)

부모 클래스의 속성과 기능을 자식 클래스가 물려받는 것

* 가상화(Virtualization)

부모 클래스의 메서드를 자식 클래스에서 재정의(override) 할 수 있게 하는 것

* 추상화(Abstraction)

공통된 개념만 뽑아 핵심적인 인터페이스만 정의하는 것

* 인터페이스(Interface)

메서드 시그니처만 정의하고, 구현은 상속받는 클래스가 담당하는 구조

* 캡슐화(Encapsulation)

데이터와 기능을 하나의 객체 안에 묶고 외부에서는 접근을 제한하는 것

[멋쟁이사자처럼부트캠프] 유니티 게임 개발 5기(2025.06.09-2025.06.13)

shine94 — Fri, 27 Jun 2025 18:05:31 +0900

* 해당 글은 유니티 게임 개발 수업 후 정리한 글입니다

https://bootcamp.likelion.net/school/kdt-ugm-5th

유니티 게임 개발 5기 : 멋사 부트캠프

개발부터 출시까지! 나만의 게임을 세상에 선보이는 유니티 부트캠프

bootcamp.likelion.net

* 캐릭터 이동 3가지

(1) Transform 이동

위치 값을 직접 수정하므로 반응이 빠르지만, 물리 계산이 무시된다

Rigidbody가 있을 경우, 충돌 처리 이상이 발생할 수 있다(예 : 관통, 튕김 무시)

[주용도]

UI, 배경, 단순 애니메이션 등 물리 반응이 필요 없는 경우

(2) Rigidbody 이동

물리 법칙(중력, 마찰, 질량 등)에 따라 자연스럽게 동작

[velocity]

속도를 직접 제어하는 가장 빠르고 직접적인 물리 이동 방식

[AddForce]

힘을 가해 가속도를 만드는 방식으로 더 자연스러운 반응 가능

(3) Character Controller 이동

충돌 처리는 자동으로 되지만, 물리 엔진(Rigidbody 등)과는 별도

스텝 기능, 경사면 이동 등 캐릭터 전용 기능 포함

중력은 직업 구현해야 하며, controller.Move()에 직접 중력 반영 필요

* Invoke, Coroutine

Invoke는 일정 시간 후 또는 일정 주기로 함수를 호출하는 간단한 방식이며,

Coroutine은 시간을 기다리거나 여러 프레임에 걸쳐 실행 흐름을 제어할 수 있는 논리적 비동기 함수이다

[C#] .NET 가비지 컬렉션(GC, Garbage collection) 둘러보기

shine94 — Wed, 25 Jun 2025 15:20:25 +0900

*참고한 공식 문서

https://learn.microsoft.com/ko-kr/dotnet/standard/garbage-collection/fundamentals

가비지 컬렉션 기본 사항 - .NET

가비지 수집기의 작동 원리와 최적 성능으로 구성하는 방법에 대해 알아봅니다.

learn.microsoft.com

https://learn.microsoft.com/ko-kr/dotnet/standard/garbage-collection/large-object-heap

Windows의 큰 개체 힙 (LOH) - .NET

이 문서에서는 큰 개체, .NET 가비지 수집기에서 관리하는 방법 및 큰 개체를 사용하는 성능에 미치는 영향에 대해 설명합니다.

learn.microsoft.com

https://learn.microsoft.com/ko-kr/dotnet/standard/garbage-collection/background-gc?utm_source=chatgpt.com

백그라운드 가비지 수집 - .NET

.NET의 백그라운드 가비지 수집 및 워크스테이션 및 서버 가비지 수집의 차이점에 대해 알아봅니다.

learn.microsoft.com

https://docs.unity3d.com/Manual/performance-reference-types.html#Garbage-collector

https://docs.unity3d.com/2023.1/Documentation/Manual/performance-incremental-garbage-collection.html?utm_source=chatgpt.com

https://docs.unity3d.com/Manual/scripting-backends-il2cpp.html

https://www.hboehm.info/gc/

A garbage collector for C and C++

A garbage collector for C and C++ [ This is an updated version of the page formerly at http://www.hpl.hp.com/personal/Hans_Boehm/gc, and before that at http://reality.sgi.com/boehm/gc.html and before that at ftp://parcftp.xerox.com/pub/gc/gc.html. ] The Bo

www.hboehm.info

https://www.oracle.com/webfolder/technetwork/tutorials/obe/java/gc01/index.html

Java Garbage Collection Basics

Java Overview Java is a programming language and computing platform first released by Sun Microsystems in 1995. It is the underlying technology that powers Java programs including utilities, games, and business applications. Java runs on more than 850 mill

www.oracle.com

https://docs.oracle.com/en/java/javase/17/gctuning/index.html

HotSpot Virtual Machine Garbage Collection Tuning Guide

This guide describes the garbage collection methods included in the Java HotSpot Virtual Machine (Java HotSpot VM) and helps you determine which one is the best for your needs.

docs.oracle.com

* Garbage Collector(GC)

[핵심 목표] 더 이상 사용하지 않는 객체의 메모리를 자동으로 찾아서 해제한다

* 동작 단계

.NET의 GC는 기본적으로 Mark → Sweep → Compact 패턴을 따른다

(1) Mark 단계 - 사용중인 객체를 표시

실행 중인 애플리케이션의 루트(Root) 객체부터 시작해 참조 체인을 따라 살아있는 객체(alive)로 표시한다

(2) Sweep 단계 - 사용하지 않는 객체를 제거

Mark 단계에서 표시되지 않는 객체를 가비지(쓰레기)로 간주하고, 그 메모리를 해제한다

[단어 뜻] 쓸다, 청소하다

(3) Compact 단계 - 살아 남은 객체를 모아 연속된 공간을 만든다

Sweep 후 생긴 메모리 빈 공간을 정리하고,

살아남은 객체들을 한쪽으로 모아 재배치(compaction)해 메모리 파편화를 줄인다

* .NET GC는 비용 절감을 위해 세대별로 나눠서 효율적으로 관리한다

[구현 요점] 일반적으로 젊은 객체는 빨리 수집되고, 오래 살아남은 객체는 높은 세대로 승격되어 더 오래 유지된다

이름	특징	대상	청소 빈도
Generation0 ( = Gen0)	새로 만들어진 ‘젊은’ 객체	단기 객체 (대부분 메서드 로컬 변수 등 임시 객체)	가장 자주 수집
Generation1 ( = Gen1)	Gen0에서 살아남은 객체	중간 생존 객체	중간 빈도로 수집
Generation2 ( = Gen2)	Gen1에서 살아남은 객체	장기 생존 객체 (싱글턴, 앱 캐시 등 장기 리소스)	비용이 가장 크고 가장 늦게 수집
LOH (Large Object Heap)	85,000바이트 이상 대규모 객체	Gen2에서 관리, 단편화 발생 가능, 기본 압축 안함	Gen2 수집 시 함께 수집

* .NET GC에서 세대별 관리하는 동작 원리

(1) 할당(Allocation)

객체가 생성되면 메모리는 관리 힙(Managed Heap)에 할당되며, Gen0 영역에 배치된다

대부분의 객체는 메서드 로컬 변수로 생성되어 짧게 사용된다

(2) GC 실행: Mark → Sweep → Compact

[2-1] 실행되는 조건

조건	설명
Gen0/Gen1 힙이 꽉 참	세대별로 설정된 최대 메모리를 모두 사용했을 때
OS가 Low Memory 신호	컴퓨터 메모리가 부족해졌을 때
명시적 호출	개발자가 GC.Collect()를 직접 호출한 경우
Background GC 주기	Gen2는 백그라운드 스레드가 주기적으로 검사하여 필요하면 작동
할당 속도가 예상보다 빠름 → Budget 초과 위험	객체 생성 속도가 빨라 곧 메모리가 모자랄 것으로 예상될 때

[2-2] Allocation Budget 원리

.NET은 각 세대별로 객체를 만들 수 있는 최대 용량(예산)을 정한다

새 객체를 만들면 그만큼 공간을 차지해 예산이 줄어든다

예산을 모두 쓰면 사용하지 않는 객체를 제거하여 공간을 비운다

최근 객체가 만드는 속도가 너무 빨라서 곧 예산을 다 쓸 것 같으면, 미리 GC를 실행해 부족하지 않게 한다

[2-3] GC 검사 순서

작은 영역부터 순서대로 점검(Gen0 → Gen1)

Gen0만 정리해도 충분하면 상위 세대는 건너뛰어 비용을 절감한다

Gen2는 백그라운드에서 주기적으로 살펴보고 필요할 때 오래된 객체를 정리한다

(3) 승격(Promotion)

Get0에서 살아남은 객체는 Get1으로 승격

Get1에서 살아남은 객체는 Get2로 승격

* ChatGPT로 만들고, 간단하게 리펙토링한 GC 예제 코드

namespace GarbageCollector
{
    // 실제 메모리에 할당된 객체를 표현하는 단위
    class GcObject
    {
        private static int _idCount = 1;
        
        private readonly List<GcObject> _references = new();     // 해당 객체가 참조하는 다른 객체 리스트, 참조하는 객체가 없으면 GC 대상이 된다

        private int _id;
        private bool _isMarked;                                 // 사용 여부 체크
        
        
        public GcObject()
        {
            _id = _idCount;
            _idCount++;
        }

        public int GetId() => _id;
        
        public bool IsMarked()
        {
            return _isMarked;
        }
        
        public void Mark()
        {
            _isMarked = true;
        }
        
        public void Unmark()
        {
            _isMarked = false;
        }

        public List<GcObject> GetReferences()
        {
            return _references;
        }
        
        public void AddReferences(GcObject reference)
        {
            _references.Add(reference);
        }
        
        public void ClearReferences()
        {
            _references.Clear();
        }
    }

    class SimpleGc
    {
        private readonly List<GcObject> _roots = new();
        
        private List<GcObject> _heap = new();

        // 루트부터 연결된 객체들을 Mark
        void Mark()
        {
            // DFS(깊이 우선 탐색)으로 참조된 모든 객체까지 전부 검사 
            var stack = new Stack<GcObject>(_roots);
            while (stack.Count > 0)
            {
                var obj = stack.Pop();
                if (!obj.IsMarked())
                {
                    obj.Mark();
                    
                    foreach (var reference in obj.GetReferences())
                        stack.Push(reference);
                }
            }
        }
        
        // Mark 안 된 객체 제거, Sweep
        void Sweep()
        {
            _heap.RemoveAll(obj =>
            {
                // 힙에서 제거, true 리턴하면 제거됨
                if (!obj.IsMarked())
                {
                    Console.WriteLine($"[SWEEP] Sweeping Obj#{obj.GetId()}");
                    return true;
                }

                // 힙에서 유지, false 리턴하면 유지
                obj.Unmark();        // 다음 GC를 위해 _isMarked값 초기화
                return false;
            });
        }

        // Compact
        void Compact()
        {
            // 진짜 Compact처럼 메모리 재배치하지는 않지만,
            // 리스트를 새로 만들어 정리된 것 같은 효과만 구현
            var newHeap = new List<GcObject>(_heap);
            _heap = newHeap;
            Console.WriteLine("[COMPACT] Heap compacted. Count: " + _heap.Count);
        }

        // GC 한 사이클 실행
        public void RunGc()
        {
            Console.WriteLine("=== GC Start ===");
            Mark();
            Sweep();
            Compact();
            Console.WriteLine("=== GC End ===\n");
        }
        
        public void AddHeap(GcObject[] insertData)
        {
            _heap.AddRange(insertData);
        }

        public void SetRoot(GcObject root)
        {
            _roots.Add(root);
        }
    }

    internal class Program
    {
        static void Main(string[] args)
        {
            var gc = new SimpleGc();

            // 객체 생성
            var obj1 = new GcObject();
            var obj2 = new GcObject();
            var obj3 = new GcObject();
            
            // 참조 관계 생성
            // obj1 → obj2 → obj3
            obj1.AddReferences(obj2);
            obj2.AddReferences(obj3);
            
            gc.AddHeap(new [] { obj1, obj2, obj3 });

            // obj1만 Root에 등록 → obj2, obj3는 obj1만 통해 접근됨
            gc.SetRoot(obj1);
            
            Console.WriteLine("[STEP 1] 모두 연결됨");
            gc.RunGc();
            
            // obj1에서 obj2로의 연결 끊기 → obj2, obj3는 더 이상 접근 불가
            obj1.ClearReferences();
            Console.WriteLine("[STEP 2] obj1 → obj2 연결 해제됨");
            gc.RunGc();
        }
    }
}

* 유니티의 GC

런타임(Mono, IL2CPP)에 따라 동작 방식이 다르다

[Mono]

기본적으로 Boehm GC를 사용하며, 옵션으로 Incremental 모드를 켤 수 있다

ㄴ Boehm GC

세대별 구조(generational GC)와는 달리, 모든 힙 영역을 한꺼번에 탐색한다

세대별 구조와 동일하게 Mark → Sweep → Compact 패턴으로 메모리 관리한다

ㄴ Incremental GC 옵션

GC 작업을 여러 프레임에 나누어 점진적으로 수행하여,

코루틴처럼 작은 단위로 실행되어 일시적인 프레임 드롭을 줄인다

[IL2CPP]

AOT(Ahead Of Time) 컴파일 환경에 맞게 Boehm GC를 내장하여 사용하며,

Mono와 동일하게 기본적으로 Boehm GC 기반으로 작동한다

Incremental GC는 IL2CPP에서는 직접 설정할 수 없고,

플랫폼과 빌드 설정에 따라 내부에서 자동으로 Boehm GC가 최적화되어 동작한다

[정리하면]

결국 Boehm GC를 사용하고, Incremental 모드를 사용할 수 있다는 점은 같다

단, Mono는 Incremental 모드를 선택할 수 있지만 IL2CPP는 내부에서 자동으로 적용된다

* AOT와 JIT 언급한 유니티 공식문서에서의 문구

This type of compilation,
in which Unity compiles code specifically for a target platform when it builds the native binary,
is called ahead-of-time (AOT) compilation.
The Mono backend compiles code at runtime,
with a technique called just-in-time compilation (JIT).

* 자바의 GC

기본적으로 세대별 GC(generational GC) 구조를 사용한다

[기본구조]

객체의 생존 기간에 따라

Young Generation, Old Generation, Permanent Generation으로 나눈다

ㄴ Young Generation

새로 생성된 객체가 주로 할당

ㄴ Old Generation

Young Generation에서 오래 살아남은 객체가 이동
ㄴ Permanent Generation(Java7까지) → Metaspace(Java8부터)

클래스 메타데이터 등을 저장

Minor GC(eden + Survivor Space)

Young Generation(Eden + Survivor Space)만 대상으로 하는 부분 수집

짧고 자주 발생하며, 살아남은 객체는 Survivor Space를 거쳐 Old Generation으로 이동

Old Generation이 차면 Major GC가 발생하고, 필요 시 힙 전체를 대상으로 Full GC가 수행된다

Major GC

Old Generation을 대상으로 하는 큰 수집

필요 시 힙 전체를 대상으로 Full GC가 수행된다

Full GC

JVM이 관리하는 모든 힙 전체(Young + Old + Metaspace)를 수집

Minor, Major보다 훨씬 무겁고 Stop-The-World(전체 멈춤) 시간도 길 수 있다

성능 문제의 주 원인으로 꼽히므로 자주 발생하지 않도록 튜닝하는 게 중요하다

[HotSpot JVM이란]
Oracle이 만든 대표적인 Java Virtual Machine(JVM) 구현체이다

[대표 GC 알고리즘]
HotSpot JVM에서는 여러 GC 알고리즘을 선택할 수 있다

(1) Serial GC

: 단일 스레드로 작동하는 단순한 GC
(2) Parallel GC

: 여러 스레드로 Young Generation을 병렬로 수집
(3) CMS GC (Concurrent Mark-Sweep)

: Old Generation을 애플리케이션과 동시에 수집하여 Stop-The-World(STW) 시간을 줄임
(4) G1 GC (Garbage First)

: 힙을 작은 Region으로 나누고 우선순위가 높은 영역부터 수집
(5) ZGC, Shenandoah GC

: 매우 짧은 지연시간을 목표로 하는 최신 GC, Java 11+에서 사용 가능