Reference Counting

---

🌞 스마트포인터의 필요성 : 틀린예시

스타크래프트에서 레이스라는 유닛이 다른 타겟을 공격하는 예시

class Wraight
{
public : 
	int _hp = 150;
	int _posX = 0;
	int _posY = 0;
};

class Missile
{
public :
	void SetTarget(Wraight* target)
	{
		_target = target;
	}

	void Update() 
	{
		int posX = _target->_posX;
		int posY = _target->_posY;
	}
	
	
	Wraight* _target = nullptr;

};


int main()
{
	Wraight* wraight = new Wraight();
	Missile* missile = new Missile();
	missile->SetTarget(wraight);


	wraight->_hp = 0;
	delete wraight;

	while (true) 
	{
		if (missile) 
		{
			missile->Update();
		}
	}
	delete missile;
}

레이스의 미사일이 타겟을 따라가게끔 만들 것이다.
만약에 레이스가 피격을 당하여 레이스가 delete가 됐습니다.
이 경우 레이스 객체를 가지고 있는 미사일 객체는 null값을 가지게 된다.
생명주기를 생각하지 않고, 객체를 참조하고 있는 다른 객체가 있음에도 delete를 해준 것이 문제가 됐다.

---

🌞 해결방법 : Reference Counting

• 객체를 참조하고 있는 객체의 갯수를 세는 메모리관리 방법이다.

RefCounting.h

#pragma once
/*--------------
	RefCountable
---------------*/


class RefCountable
{
public:
	RefCountable() : _refCount(1) { }
	virtual ~RefCountable() { }

	int32 GetRefCount() { return _refCount; }
	
	int32 AddRef() { return ++_refCount; }
	int32 ReleaseRef()
	{
		int32 refCount = --_refCount;
		if (refCount == 0) {
			delete(this);
		}
		return refCount;
	}
protected:
	int32 _refCount;
};

Main

#include "RefCounting.h"

class Wraight : public RefCountable
{
public : 
	int _hp = 150;
	int _posX = 0;
	int _posY = 0;
};

class Missile : public RefCountable
{
public :
	void SetTarget(Wraight* target)
	{
		_target = target;
		target->AddRef();
	}

	void Update() 
	{
		if (_target == nullptr) return;
		int posX = _target->_posX;
		int posY = _target->_posY;
		
		if (_target->_hp == 0)
		{
			_target->ReleaseRef();
			_target = nullptr;
		}
	}
	
	Wraight* _target = nullptr;

};


int main()
{
	Wraight* wraight = new Wraight();
	Missile* missile = new Missile();
	missile->SetTarget(wraight);

	
	wraight->_hp = 0;
	wraight->ReleaseRef();
	while (true) 
	{
		if (missile) 
		{
			missile->Update();
		}
	}
	missile->ReleaseRef();
}

---

🌞 멀티쓰레드 환경에서의 Reference Counting의 문제

위의 코드는 현재 _refCount의 값이 atomic하지 않기 때문에 멀티쓰레드 환경에서 문제가 생긴다.

그렇기 때문에 atomic으로 _refCount를 바꿔야 한다. 이렇게만 하면 될 것 같지만 안된다.

그 이유는 _refCount의 add 또는 release하는 일이 atomic하게 이루어지지 않기 때문이다.

이렇듯 수동으로 add, release를 하는 것은 좋은 방법이 아니고, 스마트포인터를 이용해서 자동으로 관리를 하는 것이 멀티쓰레드환경에서 좋은 방법이다.

---

🌞 스마트포인터 : SharedPtr

• refCounting 객체를 랩핑하여 포인터로 가지고 있다.

코드 상에서 직접적으로(수동적으로) add, release를 해주는 것이 아니라 SharedPtr에서 자동적으로(null이 되면) 해주게끔 하는 것이 컨셉이다.
RefCounting.h

#pragma once
/*--------------
	RefCountable
---------------*/


class RefCountable
{
public:
	RefCountable() : _refCount(1) { }
	virtual ~RefCountable() { }

	int32 GetRefCount() { return _refCount; }
	
	int32 AddRef() { return ++_refCount; }
	int32 ReleaseRef()
	{
		int32 refCount = --_refCount;
		if (refCount == 0) {
			delete this;
		}
		return refCount;
	}
protected:
	atomic<int32> _refCount;
};





template<typename T>
class TSharedPtr
{
public:
	TSharedPtr() { }
	TSharedPtr(T* ptr) { Set(ptr); }
	//복사
	TSharedPtr(const TSharedPtr& rhs) { Set(rhs._ptr); }
	//이동
	TSharedPtr(TSharedPtr&& rhs)
	{
		_ptr = rhs._ptr;
		rhs._ptr = nullptr;
	}
	//상속 관계 복사
	template<typename U>
	TSharedPtr(const TSharedPtr<U>& rhs) { Set(static_cast<T*>(rhs._ptr)); }

	~TSharedPtr() { Release(); }

public:
	//복사 연산자
	TSharedPtr& operator=(const TSharedPtr& rhs)
	{
		if (_ptr != rhs._ptr)
		{
			Release();
			Set(rhs._ptr);
		}
		return *this;
	}
	//이동 연산자
	TSharedPtr& operator=(TSharedPtr&& rhs)
	{
		Release();
		_ptr = rhs._ptr;
		rhs._ptr = nullptr;
		return *this;
	}

	bool		operator==(const TSharedPtr& rhs) const { return _ptr == rhs._ptr; }
	bool		operator==(T* ptr) const { return _ptr == ptr; }
	bool		operator!=(const TSharedPtr& rhs) const { return _ptr != rhs._ptr; }
	bool		operator!=(T* ptr) const { return _ptr != ptr; }
	bool		operator<(const TSharedPtr& rhs) const { return _ptr < rhs._ptr; }
	T*			operator*() const { return _ptr; }
	const T*	operator*() const { return _ptr; }
				operator T* () const { return _ptr; }
	T*			operator->() { return _ptr; }
	const T*	operator->() const { return _ptr; }

	bool isNull() { return _ptr == nullptr; }

private:
	inline void Set(T* ptr)
	{
		_ptr = ptr;
		if (ptr)
			ptr->AddRef();

	}

	inline void Release()
	{
		if (_ptr != nullptr) 
		{
			_ptr->ReleaseRef();
			_ptr = nullptr;
		}
		
	}


private:
	T* _ptr = nullptr;
};

Main

#include "pch.h"
#include <iostream>
#include "CorePch.h"
#include <atomic>
#include <mutex>
#include <windows.h>
#include <future>
#include "ThreadManager.h"

#include "RefCounting.h"

class Wraight : public RefCountable
{
public:
	int _hp = 150;
	int _posX = 0;
	int _posY = 0;
};

using WraightRef = TSharedPtr<Wraight>;

class Missile : public RefCountable
{
public:
	void SetTarget(WraightRef target)
	{
		_target = target;
		// 중간에 개입 가능
		//target->AddRef();
	}

	bool Update()
	{
		if (_target == nullptr)
			return true;

		int posX = _target->_posX;
		int posY = _target->_posY;

		// TODO : 쫓아간다

		if (_target->_hp == 0)
		{
			//_target->ReleaseRef();
			_target = nullptr;
			return true;
		}

		return false;
	}

	WraightRef _target = nullptr;
};

using MissileRef = TSharedPtr<Missile>;

int main()
{
	WraightRef wraight(new Wraight());
	wraight->ReleaseRef();
	MissileRef missile(new Missile());
	missile->ReleaseRef();

	missile->SetTarget(wraight);

	// 레이스가 피격 당함
	wraight->_hp = 0;
	//delete wraight;
	//wraight->ReleaseRef();
	wraight = nullptr;

	while (true)
	{
		if (missile)
		{
			if (missile->Update())
			{
				//missile->ReleaseRef();
				missile = nullptr;
			}
		}
	}

	//missile->ReleaseRef();
	missile = nullptr;
	//delete missile;
}

---