c++ 模拟gc垃圾回收

最新推荐文章于 2024-12-25 01:12:50 发布
最新推荐文章于 2024-12-25 01:12:50 发布
阅读量171 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： c/c++ 运维 数据结构与算法
原文链接：https://my.oschina.net/u/221120/blog/895663

2019独角兽企业重金招聘Python工程师标准>>> hot3.png

说明：代码实现借鉴这边文章

查找及回收无用对象的方法有很多种，最简单也是最早的一种方法，叫“标记-清除法”。 过程：

  1. 从根对象开始，遍历整个对象图。每访问一个对象，就把一个标记位设成true。
  2. 一旦完成遍历，找出所有没有被标记过的对象，并清除掉它们。 假设我们正在写一门小语言的解释器。它是动态类型的，有两种对象：int以及pair。下面是一个定义对象类型的枚举：
#include <assert.h>
enum Obj_Type
{
	OBJ_INT,
	OBJ_PAIR
};

实现对象类型：

struct _Object
{
	Obj_Type type;
	unsigned char marked;//标记标志，如果被标记，说明可达。
	//union 
	//{
		int value;//存储的值
		struct  
		{
			_Object* pHead;
			_Object* pTail;
		};
	//};
	_Object *pNext;
};

现在我们可以把它们封装到一个小型虚拟机的结构里了。这个虚拟机在这的作用就是持有一个栈，用来存储当前使用的变量。很多语言的虚拟机都要么是基于栈的（比如JVM和CLR），要么是基于寄存器的（比如Lua）。不管是哪种结构，实际上它们都得有一个栈。它用来存储本地变量以及表达式中可能会用到的中间变量。

#define  MAX_SIZE 256 //堆栈最大数目
#define  INITIAL_GC_THRESHOLD 128 //触发gc的对象数量
typedef struct _tagVM
{
	_Object* objs[MAX_SIZE];
	int max_objs;//产生的最大对象的数目，超过调用gc
	int num_objs;//记录现在的对象数目
//对虚拟机层面，所有的对象应该都是可见的，从用户角度，有些对象可能没有任何引用指向它，对象也就
//不可见，所以
//用链表记录通过虚拟机产生的所有对象。
	_Object *pFirstObj;//链表的头指针
	_Object *pLastObj;//链表的尾指针
	int objs_size;//堆栈大小或者堆栈指针
}VM;

创建虚拟机的函数：

VM* new_VM()
{
	VM *pVm=(VM *)malloc(sizeof(VM));
	pVm->objs_size=0;
	_Object *pObj=create_obj(OBJ_INT);
	pObj->value=0;
	pObj->marked=1;
	pObj->pHead=NULL;
	pObj->pTail=NULL;
	pObj->pNext=NULL;
	pVm->pFirstObj=pObj;//NULL;第一个节点不使用，
	pVm->pLastObj=pVm->pFirstObj;
	pVm->max_objs=INITIAL_GC_THRESHOLD;
	pVm->num_objs=0;
	return pVm;
}

释放虚拟机函数：

void delete_VM(VM *pVM)
{
	_Object *pObj=pVM->pFirstObj;
	while (pObj!=NULL)
	{
		printf("%i\t",pObj->value);
		_Object *tmp=pObj->pNext;
		delete_Obj(pObj);
		pObj=tmp;
	}
	free(pVM);
	pVM=NULL;
}

有了虚拟机后，我们需要对它的栈进行操作：

void push(VM* pVM,_Object *pObj)
{
	assert(pVM->objs_size<=MAX_SIZE ,"Stack overflow!");
	pVM->num_objs++;
	pVM->pLastObj->pNext=pObj;
	pVM->pLastObj=pObj;
	pVM->objs[pVM->objs_size++]=pObj;
	if (pVM->num_objs>pVM->max_objs)
	{
		gcVM(pVM);
	}
}
_Object * pop(VM*pVM)
{
	assert(pVM->objs_size>0 ,"Stack underflow!");
	return pVM->objs[--pVM->objs_size];
}

产生对象的函数：

_Object * create_obj(Obj_Type type)
{
	_Object *pObj=(_Object *)malloc(sizeof(_Object));
	pObj->type=type;
	pObj->marked=0;
	pObj->pNext=NULL;
	return pObj;
}

_Object * new_obj(Obj_Type type)
{
	_Object *pObj=create_obj(type);
	return pObj;
}

有了它我们就可以把不同类型的对象压到栈里了：

void push_int(VM* pVM,int value)
{
	_Object *pObj=new_obj(pVM,OBJ_INT);
	pObj->value=value;
	push(pVM,pObj);
}

_Object * push_pair(VM* pVM,int value)
{
	_Object *pObj=new_obj(pVM,OBJ_PAIR);
	pObj->value=value;
	pObj->pTail=pop(pVM);
	pObj->pHead=pop(pVM);
	push(pVM,pObj);
	return pObj;
}

如果我们有个解析器和解释器来调用这些函数，就是一门完整的语言了。下面是标记-清除过程： 第一个阶段是标记阶段，

void mark(_Object *pObj,unsigned char marked)
{
	if (pObj->marked) return;//防止pair类型相互引用，造成环回，形成无穷递归。
	printf("%i\t",pObj->value);//调试输出
	pObj->marked=marked;
	if (pObj->type==OBJ_PAIR)//pair类型，进行递归
	{
		mark(pObj->pHead,marked);
		mark(pObj->pTail,marked);
	}
}

void mark_all(VM*pVM)
{
	for (int i=0;i<pVM->objs_size;++i)
	{
		//printf("%i\t",pVM->objs[i]->value);
		if (pVM->objs[i]->type==OBJ_PAIR)//堆栈中的非Pair节点，认为不可达
		{
			mark(pVM->objs[i],1);
		}

	}
}

下一个阶段就是遍历所有分配的对象，释放掉那些没有被标记的了,

void sweep(VM* pVM)
{
	_Object *pObj=NULL,*pFrontObj=NULL;
	pObj=pFrontObj=pVM->pFirstObj;
	while (pObj!=NULL)
	{

		if (!pObj->marked)
		{
			printf("%d\t",pObj->value);//调试输出
			pFrontObj->pNext=pObj->pNext;//删除链表节点，调整前后指针指向
			_Object *tmp=pObj;
			pFrontObj=pObj=pFrontObj->pNext;
			free(tmp);
			pVM->num_objs--;//目前对象数目减一
		}
		else
		{
			pFrontObj=pObj;
			pObj=pObj->pNext;
		}

	}
}

最后，有了一个垃圾回收器：

void gcVM(VM*pVM)
{
	mark_all(pVM);
	sweep(pVM);
	//每次回收之后，我们会根据存活对象的数量，更新maxOjbects的值。
	//这里乘以2是为了让我们的堆能随着存活对象数量的增长而增长。
	//	同样的，如果大量对象被回收之后，堆也会随着缩小
	pVM->max_objs = pVM->num_objs * 2;
}

然后，我们在new_obj根据对象产生的数目来触发gc。 我们来产生一些对象来测试gc:

int _tmain(int argc, _TCHAR* argv[])
{
	VM *pVM=new_VM();
	for (int i=0;i<10;++i)//产生一些对象
	{
		push_int(pVM,10);
		push_int(pVM,15);
		push_pair(pVM,20);//使堆栈中丢失前面的两个对象指针
		push_int(pVM,30);//不可达
	}
	printf("mark_all:\n");
	mark_all(pVM);
	printf("sweep:\n");
	sweep(pVM);
	printf("delete_VM:\n");
	delete_VM(pVM);
	getchar();
	return 0;
}

最终如下：

输入图片说明

转载于:https://my.oschina.net/u/221120/blog/895663

PHP 垃圾回收 GC 机制、人工介入释放内存
wgchen
12-23 952
PHP 垃圾回收 GC 机制、人工介入释放内存
C++中的GC（垃圾回收）
qq_40165959的博客
10-12 4917
简述 网上有不少人认为，标准c++是没有GC的。实际上，为了运行效率的提高以及在嵌入式设备上运行，c++不提供语言层面的GC。但是，c++头文件memory提供了智能指针std::shared_ptr，作GC的用途。这使得我们可以决定哪些指针需要GC、哪些不需要，以免不必要的消耗。 头文件 要使用std::shared_ptr，需要引入头文件memory，如下： #include <memo...
再论C++之垃圾回收（GC）
热门推荐
QBox/Golang/CERL/StdExt/TPL/WinxGui - 许式伟的专栏
11-24 3万+
本文已经迁移到： http://cpp.winxgui.com/cn:garbage-collection-in-cplusplus使用智能指针（smart pointers） http://www.codeproject.com/cpp/garbage_collect.asp 原理：基于引用计数（reference count）。这种垃圾回收（gc）算法无非都是给每一
GC(C++ 代码的优化器)
05-13
C++ 代码的优化器
C++实现垃圾回收器（GC）
qq285503851的博客
11-27 2097
C++实现垃圾回收器（GC），下面将写一个类，只要继承这个类，在合适的位置使用GC::instance.collect();就可以批量delete已申请的内存，如果有一些内存不需要释放可以添加例外GC::instance.pin(p2);，使用GC::instance.unpin§;在.net中，不必考虑内存问题，因为有垃圾回收机制，但是在C++中，必须靠程序员释放申请的内存空间，如果操作不得当，很有可能会内存泄漏。
如何给C++设计一个GC
weixin_34414196的博客
10-26 315
和同事聊起了这个话题，下面是一些思考与问题： 【思考】 基本套路与Java应该是一致的，也就是Mark - Sweep - Compact： C++中可分为两种类型：一是用户自定义类型；一种是内置的类型。 每次分配内存时候，都把内存地址保存到一个hashmap中，key为内存地址，value为false。这是准备工作，然后在某个时间点需要做垃圾回收的时候： 寻找以下三种用户自定义类型...
Java 垃圾回收（GC）浅析
进一步有进一步的欢喜~
12-25 897
本文全面解析了 Java 垃圾回收（GC）机制，涵盖其定义、必要性、工作原理及常见算法，如标记-清除、复制和分代收集。详细介绍了多种 GC 收集器及其适用场景，并探讨了如何通过 GC 日志和监控工具优化性能。此外，本文还列举了内存泄漏检测与预防的方法，以及相关的知识点，如弱引用和 JIT 编译器优化，帮助读者理解并有效管理 Java 应用的内存使用，提升程序性能。
C++为何不采用垃圾回收机制的深度解析
实际上，通过智能指针（如`std::shared_ptr`和`std::unique_ptr`）和RAII（Resource Acquisition Is Initialization）原则，C++提供了一种方式来模拟垃圾回收的效果，确保当对象生命周期结束时，相关资源会被正确...
C++实现自动内存管理的垃圾回收器
而垃圾回收管理类正是这一理念的具体实践，它利用C++的高级特性（如对象生命周期管理）来模拟垃圾回收。 ### 知识点二：C++智能指针 智能指针是C++标准库提供的一类特殊的指针，它们会自动释放所拥有的资源。这是...
C++ 简述GC
最新发布
08-20
- C++的目标是提供高性能和灵活性，因此标准库不强制垃圾回收，但允许通过智能指针和第三方库模拟自动回收。 #### 2. **核心机制：C++如何实现垃圾回收？** C++主要通过以下方式实现垃圾回收功能，这些机制基于...
一个简单的C++垃圾回收器实现（GC）
weixin_33682719的博客
08-09 620
在C++本来是没有垃圾回收器的，而随着内存的廉价一些新型的语言都加入了垃圾回收的策略（Garbage Collection），比如Java，C#等语言。带着垃圾回收原理的探究的想法，这里简单实现一个垃圾回收器：采用引用计数的方法。使用C++语言。代码完整/********************** **gc.h ***********************/ #i...
最简单最实用的C++ GC
12-23 1021
//SPtr.h#ifndef S_PTR_H#define S_PTR_Htemplate typename T0, typename T1 = unsigned int> class SPtr{ template typename T0, typename T1> friend class SPtr;public: SPtr(T0 * ptr = 0)  :ptr_(ptr), use_(ne
GC基本算法及C++GC机制
weixin_34419321的博客
12-27 647
前言 垃圾收集器是一种动态存储分配器，它自动释放程序不再需要的已分配的块，这些块也称为垃圾。在程序员看来，垃圾就是不再被引用的对象。自动回收垃圾的过程则称为垃圾收集（garbage collection）。在一个支持垃圾收集的语言中，程序显式地申请内存，但从不需要显式的释放它们。垃圾收集器会定期识别垃圾块，并将垃圾块放回空闲链表中。显然，C语言的malloc包不是一个带GC功能的分配器，程序员显式...
C++简单实现GC和内存池
略游
07-22 2843
C++简单实现GC和内存池   本章前言：     这章就是为了避开传统的new\delete创建堆对象的手法，如果使用不当指针容易出现问题，所以本章简单的实现了引用计数垃圾回收，使用起来貌似还不错。Bug还有待测试。   最终效果：     通过DND_GC_CLASS宏来定义一个Student类后，用户还是能通过正常的方法使用Student类。但宏额外生成了HStudent类，通过这个
GC模拟Demo
qq_41054844的博客
02-28 253
【代码】GC模拟Demo。
模拟GC触发并且监测GC变化
孩子眼里的钢铁侠&每天进步一点点
03-01 374
打印详细的GC信息命令:-XX:+PrintGCDetails;监测工具:VisualVM 模拟大对象,触发GC -XX:+PrintGCDetails 打印GC信息 VisualVM启动 package com.lyb269.jvm.gc; import org.junit.Test; import java.text.SimpleDateFormat; import ja...
GC垃圾回收器
程序员日记
04-10 929
垃圾回收算法 01、垃圾回收的过程 在分代收集算法下： 当JVM内存不足时，就会触发年轻代得GC； 首先，会通过可达性分析来判断哪些对象垃圾对象； 接着，将这些对象放入死亡队列，进行对象得死亡判断与回收； 如果上述GC后，内存还不够。就会触发老年代GC。如果内存还不够，就会触发Full GC。 02、三种GC （1）Minor GC 在年轻代进行垃圾回收； 这种GC速度快、效率高、回收率高；...
[原创]CLR GC垃圾收集过程模拟（用C#来显示垃圾收集过程的视觉效果）
weixin_33862188的博客
10-03 185
...... 废话不多说了，本人是搞Web方向的，C/S不太熟悉，先看界面图（比较粗糙），这里仅仅是从一个视觉的效果来初步显示GC相对应的操作（简单的效果显示，并不是真正的GC内幕，那个我也不懂）   基本概念 对象的生成过程（newobj指令） 1：计算类型（包括基类）所有字段的字节总数 2: 字节总数再加上对象开销字段字节数（相加为：对象所需的字节数）。每个对象包含2个开销字段...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值