CN106547603B - 减少golang语言***垃圾回收时间的方法和装置 - Google Patents

Abstract

本发明公开了一种减少golang语言***垃圾回收时间的方法和装置，涉及计算机技术领域。所述方法包括：为哈希表中的每个哈希桶分配一个连续的内存空间；将对应所述哈希桶的各元素存储在所述连续的内存空间中；在对哈希表执行垃圾回收时，对每个哈希桶中的各元素进行一次性释放。本发明取得了可以将同一个bucket下的元素一次性释放，大大降低释放的对象的数量，提高了释放的效率，降低了GC暂停的时间，降低GC暂停对外部的访问请求的影响有益效果。

Description

减少golang语言***垃圾回收时间的方法和装置

技术领域

本发明涉及计算机技术领域，具体涉及一种减少golang语言***垃圾回收时间的方法和装置。

背景技术

Golang语言是由Google开发的一个开源项目，其目的之一为了提高开发人员的编程效率。Golang语言语法灵活、简洁、清晰、高效，它对的并发特性可以方便地用于多核处理器和网络开发，同时灵活新颖的类型***可以方便地编写模块化的***。go可以快速编译，同时具有垃圾内存自动回收功能，并且还支持运行时反射。Go是一个高效、静态类型，但是又具有解释语言的动态类型特征的***级语法。

在先技术中，通过golang语言设计***时，可以设计一种GC(garbagecollection，垃圾回收)机制，该GC机制可以对不需要的资源进行回收，即对不需要的元素的对象进行释放；该GC机制执行时，***会暂停，则***会存在GC暂停时间。并且，在golang语言的架构下，其采用map(映射)来记录各个元素，而map记录哈希表的元素时，即记录key和value键值对时，对录key和value各自均是以一个对象进行记录的。在golang语言设计的***中，如果该***的GC(garbage collection，垃圾回收)机制判断不再需要这个map记录的元素，需要回收资源，则需要将这个map下的对象全部释放。

但是，由于***在进行垃圾回收时，如果对象过多，其释放过程就非常长，GC暂停时间也会很长。因而在先技术对于要求响应时间较短的线上***来说，上述较长时间的GC暂停时间，使***无法及时对访问请求进行响应，也使用户的等待时间较长，降低***的友好性。

发明内容

鉴于上述问题，提出了本发明以便提供一种克服上述问题或者至少部分地解决上述问题的减少golang语言***垃圾回收时间的装置和相应的减少golang语言***垃圾回收时间的方法。

依据本发明的一个方面，提供了一种减少golang语言***垃圾回收时间的方法，包括：

在哈希表的每个哈希桶之中，为一个对象分配一个连续的内存空间；

将对应所述哈希桶的各元素存储在所述连续的内存空间中；

在对各个元素执行垃圾回收时，对每个哈希桶之中的对象进行一次性释放。

优选地，所述在哈希表的每个哈希桶之中，为一个对象分配一个连续的内存空间，包括：

针对哈希表的每个哈希桶生成一个对象，并在哈希桶内存储元素指针；

分配一个连续的内存空间，并将所述元素指针指向所述连续的内存空间。

优选地，所述在哈希表的每个哈希桶之中，为一个对象分配一个连续的内存空间，包括：

在哈希表的每个哈希桶之中，通过slice切片为一个对象分配一个连续的内存空间。

优选地，所述在哈希表的每个哈希桶之中，通过slice切片为一个对象分配一个连续的内存空间，包括：

通过make函数对slice切片进行初始化，获得数组内存空间；所述数组内存空间包括N个连续的分段。

优选地，所述将对应所述哈希桶的各元素存储在所述连续的内存空间中，包括：

当初始化得到的分段的个数大于等于哈希桶的元素的个数N时，将对应该哈希桶的元素逐个存储到所述分段；

当初始化得到的分段的个数小于哈希桶的元素的个数N时，在存储到初始化的分段中的最后一个分段后，通过append函数逐个添加新的分段并对元素进行存储。

优选地，所述元素包括key和value键值对。

优选地，所述在对各个元素执行垃圾回收时，对每个哈希桶之中的对象进行一次性释放，包括：

在对各个元素执行垃圾回收时，释放每个哈希桶对应的内存空间，并将释放所述元素指针。

本发明公开了一种减少golang语言***垃圾回收时间的装置，包括：

连续空间分配模块，适于对于哈希表的每个哈希桶，为所述哈希桶分配一个连续的内存空间；

元素存储模块，适于将对应所述哈希桶的各元素存储在所述连续的内存空间中；

回收模块，适于在对各个元素执行垃圾回收时，对每个哈希桶之中的对象进行一次性释放。

优选地，所述连续空间分配模块包括：

指针存储子模块，适于针对哈希表的每个哈希桶生成一个对象，并在哈希桶内存储元素指针；

空间分配子模块，适于分配一个连续的内存空间，并将所述元素指针指向所述连续的内存空间。

优选地，所述连续空间分配模块包括：

分段空间分配子模块，适于在哈希表的每个哈希桶之中，通过slice切片为一个对象分配一个连续的内存空间。

优选地，所述切分空间分配子模块包括：

初始分段空间分配子模块，适于通过make函数对slice切片进行初始化，获得数组内存空间；所述数组内存空间包括多个连续的分段。

优选地，所述元素存储模块包括：

第一存储模块，适于当初始化得到的分段的个数大于等于哈希桶的元素的个数N时，将对应该哈希桶的元素逐个存储到所述分段；

第二存储模块，适于当初始化得到的分段的个数小于哈希桶的元素的个数N时，在存储到初始化的分段中的最后一个分段后，通过append函数逐个添加新的分段并对元素进行存储。

优选地，所述元素包括key和value键值对。

优选地，所述回收模块包括：

释放子模块，适于在对各个元素执行垃圾回收时，释放每个哈希桶对应的内存空间，并将释放所述元素指针。

根据本发明的减少golang语言***垃圾回收时间的方法和装置，可以在基于golang语言构建的服务器***中，对于需要用到的哈希表，将该哈希表的bucket(哈希桶)为对象，对其构建一个连续的内存空间，然后将对应该bucket的哈希表中的元素，逐个存入该连续的内存空间中，从而在***需要执行GC时，由于很多个元素在一个对象的连续的内存空间中，那么对于这些元素的释放只需要对该bucket进行一次性释放即可，由此解决了在先技术中采用map对元素进行存储时需要对每个元素的key和value创建对象，使对象数量特别庞大，***执行GC时，由于释放的对象数量庞大，导致GC暂停时间很长，影响***对外部的访问请求的处理，取得了可以将同一个bucket下的元素一次性释放，大大降低释放的对象的数量，提高了释放的效率，降低了GC暂停的时间，降低GC暂停对外部的访问请求的影响有益效果。

上述说明仅是本发明技术方案的概述，为了能够更清楚了解本发明的技术手段，而可依照说明书的内容予以实施，并且为了让本发明的上述和其它目的、特征和优点能够更明显易懂，以下特举本发明的具体实施方式。

附图说明

通过阅读下文优选实施方式的详细描述，各种其他的优点和益处对于本领域普通技术人员将变得清楚明了。附图仅用于示出优选实施方式的目的，而并不认为是对本发明的限制。而且在整个附图中，用相同的参考符号表示相同的部件。在附图中：

图1示出了根据本发明一个实施例的其示出了本发明实施例的一种减少golang语言***垃圾回收时间的方法的流程示意图；

图1A示出了哈希桶的逻辑架构示例；

图2示出了根据本发明一个实施例的其示出了本发明实施例的一种减少golang语言***垃圾回收时间的方法的流程示意图；

图2A示出了本发明实施例对元素的存储逻辑示意图；

图2B示出了map对元素的存储逻辑示意图；

图3示出了根据本发明一个实施例的其示出了本发明实施例的一种减少golang语言***垃圾回收时间的装置的结构示意图；以及

图4示出了根据本发明一个实施例的其示出了本发明实施例的一种减少golang语言***垃圾回收时间的装置的结构示意图。

具体实施方式

下面将参照附图更详细地描述本公开的示例性实施例。虽然附图中显示了本公开的示例性实施例，然而应当理解，可以以各种形式实现本公开而不应被这里阐述的实施例所限制。相反，提供这些实施例是为了能够更透彻地理解本公开，并且能够将本公开的范围完整的传达给本领域的技术人员。

实施例一

参照图1，其示出了本发明实施例的一种减少golang语言***垃圾回收时间的方法的流程示意图，该方法具体可以包括：

步骤110，在哈希表的每个哈希桶之中，为一个对象分配一个连续的内存空间；

本发明实施例以golang语言构建服务器的***。

那么对于该***中的各种数据，如果需要使用的哈希表，本发明实施例不执行golang语言原有的通过map形式对哈希表中的元素进行存储的逻辑。转而执行本发明步骤110的逻辑。

本发明实施例中对于哈希表中的元素在存储时，首先可将各个元素分配到各个bucket(哈希桶)中，因此一个bucket可以对应记录一个或者多个元素。在元素数量比较庞大时，比如上千万条，一个bucket可以记录更多的元素。

如图1A，其是哈希表对应bucket的逻辑架构示意图，一个哈希表中的元素可以分散到各个bucket，每个bucket对于多个元素。具体的将元素分散到各个bucket的分散算法本发明不对其加以限制。

本发明实施例中，对于一个bucket，生成一个对象，而***在生成对象时需要为该对象分配***资源，比如内存空间，那么本发明则为该对象分配一个连续的内存空间。该连续的内存空间可以分为连续的多个分段，每个分段存储同样格式的数据。在本发明实施例中，可以根据key和value的数据大小确定连续内存空间中分段的大小，在实际应用中，可以设定一个分段的大小的数值，该数值大于各key+value的最大数据大小的数值。

优选的，步骤110所述的在哈希表的每个哈希桶之中，为一个对象分配一个连续的内存空间，包括：

子步骤111，针对哈希表的每个哈希桶生成一个对象，并在哈希桶内存储元素指针；

在实际应用中，会为每个bucket生成一个对象，并在哈希桶内存储元素指针*elems。

子步骤112，分配一个连续的内存空间，并将所述元素指针指向所述连续的内存空间。

对于生成的对象，需要为其分配内存空间，本发明实施例则为其分配一个连续的内存空间，该连续的内存空间可分为连续的分段，然后即可将前述元素指针*elmes指向该内存空间。如此，在***通过查询元素时，可以通过该元素指针找到元素的存储位置。

步骤120，将对应所述哈希桶的各元素存储在所述连续的内存空间中；

对于一个bucket，由于通过分散算法将哈希表中的某些元素分散到该bucket中，那么对于这些元素，则可以逐个写入该连续的内存空间中。每个元素写入一个分段中。

对于哈希表的元素，其是以key-value键值对存在，key是采用某种哈希算法对源数据进行计算得到，value为源数据中需要使用的具体内容。比如源数据为成绩记录“张三，93分”，则可以对“张三”进行哈希计算得到key，然后在value＝“93”。

通过上述方式，本发明实施例将一个bucket的所有key-value键值对一起作为前述对象的中的数据，而不是在先的map技术中分别对key生成对象并分配一个独立内存空间进行记录，然后再对value生成对象并分配一个独立内存空间进行记录。本发明实施例生成的对象大大减少，***开销也大大减少。

步骤130，在对各个元素执行垃圾回收时，对每个哈希桶之中的对象进行一次性释放。

在服务器***运行的过程中，可能需要释放暂时不用的资源，比如前述哈希表的元素暂时可能不用，或者这些元素已经过期，那么需要对这些元素占用的资源进行回收，即执行GC过程。本发明实施例在执行GC过程时，对于哈希表的元素，由于一个bucket的各个元素在一个对象中，则本发明只需对该对象释放一次，就可以将该bucket的所有元素释放掉，不用分别每个元素的key和value单独进行释放。释放完毕之后，***的GC执行完毕，则恢复对外部访问请求的处理。

在实际中，由于***执行GC过程，***需要暂停，对于实时的线上***而言，GC暂停的时间越短越好，如果GC暂停时间长，则会影响用户对该服务器的访问，比如用户对该服务器在GC暂停开始时发送访问请求，如果GC暂停时间短，则服务器对该访问请求的响应延时就低，如果GC暂停时间长，则服务器对该访问请求的响应延时就长，用户也感觉很长时间未对其的访问请求进行处理。

而由于在先技术中，对于golang语言的***中的哈希表，是以map的形式进行存储，而map对于哈希表中的key-value键值对，对key以对象的形式进行存储，对value也会以对象的形式进行存储，而对于***而言，每个对象都会分配一个独立的内存空间，在释放时，每个对象均需要释放一次，而每次释放是需要时间的，大批量的对象释放时间累积起来，会导致GC暂停时间较长，使***对外部的访问请求的处理延时也比较长。

而本发明实施例，由于不需要针对每个元素的key和value单独生成对象并为其分配独立内存空间以存储，并且一个bucket的多个元素也放在一个对象的连续内存空间中存储，因此对象的数量大大减少，执行GC时，释放一个对象即可释放多个元素，大大减少了对哈希表的各个元素的释放时间，降低了GC暂停时间，缩短了***对外部的访问请求的处理延时。

实施例二

参照图1，其示出了本发明实施例的一种减少golang语言***垃圾回收时间的方法的流程示意图，该方法具体可以包括：

步骤210，在哈希表的每个哈希桶之中，通过slice切片为一个对象分配一个连续的内存空间；

本发明实施例以golang语言构建服务器的***。

那么对于该***中的各种数据，如果需要使用的哈希表，本发明实施例不执行golang语言原有的通过map形式对哈希表中的元素进行存储的逻辑。转而执行本发明步骤110的逻辑。

本发明实施例中对于哈希表中的元素在存储时，首先可将各个元素分配到各个bucket(哈希桶)中，因此一个bucket可以对应记录一个或者多个元素。在元素数量比较庞大时，比如上千万条，一个bucket可以记录更多的元素。

本发明实施例中，slice切片是一个动态底层数组，是一个底层的数据结构类型，其原型为：

struct Slice{

byte*array；

uintgo len；

unitgo cap；}

slice切片包括三个成员：array为底层数组，其对应连续的内存空间，底层数组可以分为N段，每段存储一个元素；len为实际存放的元素个数；cap为切片的总容量。

本发明实施例中，对于一个bucket，生成一个对象，而***在生成对象时需要为该对象分配内存空间，本发明实施例则通过slice切片，为该对象分配一个连续的内存空间。

优选的，步骤210所述的在哈希表的每个哈希桶之中，通过slice切片为一个对象分配一个连续的内存空间，包括：

子步骤211，通过make函数对slice切片进行初始化，获得数组内存空间；所述数组内存空间包括N个连续的分段。

在本发明实施例中***会调用make函数对slice切片进行初始化，即根据前述的array、len、cap，确定生成多长的内存空间。所述内存空间包括N个连续的分段。其中N为大于0的整数。在本发明实施例中，如果设置cap的值，则初始化相应个数的底层数组。

make()函数是Golang语言提供的内置函数可以用于灵活地创建slice切片。比如创建一个初始元素个数为5的slice切片，元素初始值为0，其代码为：

mySlice1:＝make([]int,5)

在实际应用中，本发明实施例针对哈希表的每个哈希桶生成一个对象，并在哈希桶内存储元素指针，然后对于前述的连续内存空间，即slice切片，将所述元素指针指向所述slice切片。

步骤220，将对应所述哈希桶的各元素存储在所述连续的内存空间中；

在本发明实施例中，在为一个bucket分配了连续的内存空间之后，比如前述底层数组空间中，则可以将该bucket的元素逐个写入在该连续的内存空间中。

在本发明实施例中，则将bucket的元素指针指向该slice切片。如图2A，其为本发明实施例的一个bucket的各元素的存储示意图，其一个元素指针指向一个连续的内存空间，该内存空间中存储了该bucket的各个元素。

为了方便对比，如图2B，其为map对元素的存储结构示例，由于其key和value均为对象，为了方便描述，对象均以Ei表示。图2B中，每个对象Ei都有一个前向指针Pi1和后向指针Pi2，因此map中不仅对象多，而且指针也很多。而本发明实施例的图2A的逻辑示意图，多个元素只有一个指针，并且这些元素在一个对象中。

优选的，所述将对应所述哈希桶的各元素存储在所述连续的内存空间中包括：

子步骤221，当初始化得到的分段的个数大于等于哈希桶的元素的个数N时，将对应该哈希桶的元素逐个存储到所述分段；

如前所述，slice切片是一个动态数组，在初始化时可以只初始化预置长度的数组内存空间。比如初始化存储3个元素的数组内存空间，即该数组内存空间有3个分段段。那么如果该bucket对应3个元素，要将其存储到数组内存空间中，直接将3个元素逐个写入各个分段中。

子步骤222，当初始化得到的分段的个数小于哈希桶的元素的个数N时，在存储到初始化的分段中的最后一个分段后，通过append函数逐个添加新的分段并对元素进行存储。

而如果该bucket对应5个元素，那么初始化的有3个分段的数组内存空间长度不够，那么则需要动态的在第3个分段之后新加一个分段，将新的剩余的2个元素中的一个写入该分段，然后在第4个分段之后，新加一个分段并将剩余的1个元素写入该分段。其新增分段并写入元素的函数为append函数，其函数原型是：append(slice[]T,elements...T)。

步骤230，在对各个元素执行垃圾回收时，对每个哈希桶之中的对象进行一次性释放。

在服务器***运行的过程中，可能需要释放暂时不用的资源，比如前述哈希表的元素暂时可能不用，或者这些元素已经过期，那么需要对这些元素占用的资源进行回收，即执行GC过程。本发明实施例在执行GC过程时，对于哈希表的元素，由于一个bucket的各个元素在一个对象中，则本发明只需对该对象释放一次，就可以将该bucket的所有元素释放掉，不用分别每个元素的key和value单独进行释放。释放完毕之后，***的GC执行完毕，则恢复对外部访问请求的处理。

优选的，所述在对各个元素执行垃圾回收时，对每个哈希桶之中的对象进行一次性释放，包括：

子步骤231，在对各个元素执行垃圾回收时，释放每个哈希桶对应的内存空间，并将释放所述元素指针。

在实际GC过程中，对于对象的释放是释放目标数据所在的内存空间，并可以将相应指向该内存空间的指针也释放掉，以回收内存资源。当然实际应用中，也可以不释放指针，而将指针设置为NULL，以避免程序崩溃。

而如图2B，map在GC过程中，除了要进行非常多的释放过程，还需要对大量的指针进行处理，其GC暂停的时间相当长。

本发明实施例由于不需要针对每个元素的key和value单独生成对象并为其分配独立内存空间以存储，并且一个bucket的多个元素也放在一个对象的连续内存空间中存储，因此对象的数量大大减少，并且一个bucket只有一个指向slice切片的指针，执行GC时，释放一个对象即可释放多个元素，并且只对该对象的一个指针进行处理，大大减少了对哈希表的各个元素的释放时间，降低了GC暂停时间，缩短了***对外部的访问请求的处理延时。

实施例三

参照图3，其示出了本发明实施例的一种减少golang语言***垃圾回收时间的装置的结构示意图，该装置具体可以包括：

连续空间分配模块310，适于对于哈希表的每个哈希桶，为所述哈希桶分配一个连续的内存空间；

元素存储模块320，适于将对应所述哈希桶的各元素存储在所述连续的内存空间中；

回收模块330，适于在对各个元素执行垃圾回收时，对每个哈希桶之中的对象进行一次性释放。

优选地，所述连续空间分配模块包括：

指针存储子模块，适于针对哈希表的每个哈希桶生成一个对象，并在哈希桶内存储元素指针；

空间分配子模块，适于分配一个连续的内存空间，并将所述元素指针指向所述连续的内存空间。

实施例四

参照图4，其示出了本发明实施例的一种减少golang语言***垃圾回收时间的装置的结构示意图，该装置具体可以包括：

连续空间分配模块410，适于对于哈希表的每个哈希桶，为所述哈希桶分配一个连续的内存空间，具体可以包括：

分段空间分配子模块411，适于在哈希表的每个哈希桶之中，通过slice切片为一个对象分配一个连续的内存空间。

元素存储模块420，适于将对应所述哈希桶的各元素存储在所述连续的内存空间中；

回收模块430，适于在对各个元素执行垃圾回收时，对每个哈希桶之中的对象进行一次性释放。

优选地，所述切分空间分配子模块包括：

初始分段空间分配子模块，适于通过make函数对slice切片进行初始化，获得数组内存空间；所述数组内存空间包括多个连续的分段。

优选地，所述元素存储模块包括：

第一存储模块，适于当初始化得到的分段的个数大于等于哈希桶的元素的个数N时，将对应该哈希桶的元素逐个存储到所述分段；

第二存储模块，适于当初始化得到的分段的个数小于哈希桶的元素的个数N时，在存储到初始化的分段中的最后一个分段后，通过append函数逐个添加新的分段并对元素进行存储。

优选地，所述元素包括key和value键值对。

优选地，所述回收模块包括：

释放子模块，适于在对各个元素执行垃圾回收时，释放每个哈希桶对应的内存空间，并将释放所述元素指针。

在此提供的算法和显示不与任何特定计算机、虚拟***或者其它设备固有相关。各种通用***也可以与基于在此的示教一起使用。根据上面的描述，构造这类***所要求的结构是显而易见的。此外，本发明也不针对任何特定编程语言。应当明白，可以利用各种编程语言实现在此描述的本发明的内容，并且上面对特定语言所做的描述是为了披露本发明的最佳实施方式。

在此处所提供的说明书中，说明了大量具体细节。然而，能够理解，本发明的实施例可以在没有这些具体细节的情况下实践。在一些实例中，并未详细示出公知的方法、结构和技术，以便不模糊对本说明书的理解。

类似地，应当理解，为了精简本公开并帮助理解各个发明方面中的一个或多个，在上面对本发明的示例性实施例的描述中，本发明的各个特征有时被一起分组到单个实施例、图、或者对其的描述中。然而，并不应将该公开的方法解释成反映如下意图：即所要求保护的本发明要求比在每个权利要求中所明确记载的特征更多的特征。更确切地说，如下面的权利要求书所反映的那样，发明方面在于少于前面公开的单个实施例的所有特征。因此，遵循具体实施方式的权利要求书由此明确地并入该具体实施方式，其中每个权利要求本身都作为本发明的单独实施例。

本领域那些技术人员可以理解，可以对实施例中的设备中的模块进行自适应性地改变并且把它们设置在与该实施例不同的一个或多个设备中。可以把实施例中的模块或单元或组件组合成一个模块或单元或组件，以及此外可以把它们分成多个子模块或子单元或子组件。除了这样的特征和/或过程或者单元中的至少一些是相互排斥之外，可以采用任何组合对本说明书(包括伴随的权利要求、摘要和附图)中公开的所有特征以及如此公开的任何方法或者设备的所有过程或单元进行组合。除非另外明确陈述，本说明书(包括伴随的权利要求、摘要和附图)中公开的每个特征可以由提供相同、等同或相似目的的替代特征来代替。

此外，本领域的技术人员能够理解，尽管在此所述的一些实施例包括其它实施例中所包括的某些特征而不是其它特征，但是不同实施例的特征的组合意味着处于本发明的范围之内并且形成不同的实施例。例如，在下面的权利要求书中，所要求保护的实施例的任意之一都可以以任意的组合方式来使用。

本发明的各个部件实施例可以以硬件实现，或者以在一个或者多个处理器上运行的软件模块实现，或者以它们的组合实现。本领域的技术人员应当理解，可以在实践中使用微处理器或者数字信号处理器(DSP)来实现根据本发明实施例的减少golang语言***垃圾 回收时间的设备中的一些或者全部部件的一些或者全部功能。本发明还可以实现为用于执行这里所描述的方法的一部分或者全部的设备或者装置程序(例如，计算机程序和计算机程序产品)。这样的实现本发明的程序可以存储在计算机可读介质上，或者可以具有一个或者多个信号的形式。这样的信号可以从因特网网站上下载得到，或者在载体信号上提供，或者以任何其他形式提供。

应该注意的是上述实施例对本发明进行说明而不是对本发明进行限制，并且本领域技术人员在不脱离所附权利要求的范围的情况下可设计出替换实施例。在权利要求中，不应将位于括号之间的任何参考符号构造成对权利要求的限制。单词“包含”不排除存在未列在权利要求中的元件或步骤。位于元件之前的单词“一”或“一个”不排除存在多个这样的元件。本发明可以借助于包括有若干不同元件的硬件以及借助于适当编程的计算机来实现。在列举了若干装置的单元权利要求中，这些装置中的若干个可以是通过同一个硬件项来具体体现。单词第一、第二、以及第三等的使用不表示任何顺序。可将这些单词解释为名称。

本发明公开了A1、一种减少golang语言***垃圾回收时间的方法，包括：

在哈希表的每个哈希桶之中，为一个对象分配一个连续的内存空间；

将对应所述哈希桶的各元素存储在所述连续的内存空间中；

在对各个元素执行垃圾回收时，对每个哈希桶之中的对象进行一次性释放。

A2、根据A1所述的方法，所述在哈希表的每个哈希桶之中，为一个对象分配一个连续的内存空间，包括：

针对哈希表的每个哈希桶生成一个对象，并在哈希桶内存储元素指针；

分配一个连续的内存空间，并将所述元素指针指向所述连续的内存空间。

A3、根据A1所述的方法，所述在哈希表的每个哈希桶之中，为一个对象分配一个连续的内存空间，包括：

在哈希表的每个哈希桶之中，通过slice切片为一个对象分配一个连续的内存空间。

A4、根据A3所述的方法，所述在哈希表的每个哈希桶之中，通过slice切片为一个对象分配一个连续的内存空间，包括：

通过make函数对slice切片进行初始化，获得数组内存空间；所述数组内存空间包括N个连续的分段。

A5、根据A4所述的方法，所述将对应所述哈希桶的各元素存储在所述连续的内存空间中，包括：

当初始化得到的分段的个数大于等于哈希桶的元素的个数N时，将对应该哈希桶的元素逐个存储到所述分段；

当初始化得到的分段的个数小于哈希桶的元素的个数N时，在存储到初始化的分段中的最后一个分段后，通过append函数逐个添加新的分段并对元素进行存储。

A6、根据A1所述的方法，所述元素包括key和value键值对。

A7、根据A2所述的方法，所述在对各个元素执行垃圾回收时，对每个哈希桶之中的对象进行一次性释放，包括：

在对各个元素执行垃圾回收时，释放每个哈希桶对应的内存空间，并将释放所述元素指针。

本发明公开了B8、一种减少golang语言***垃圾回收时间的装置，包括：

连续空间分配模块，适于对于哈希表的每个哈希桶，为所述哈希桶分配一个连续的内存空间；

元素存储模块，适于将对应所述哈希桶的各元素存储在所述连续的内存空间中；

回收模块，适于在对各个元素执行垃圾回收时，对每个哈希桶之中的对象进行一次性释放。

B9、根据B8所述的装置，所述连续空间分配模块包括：

指针存储子模块，适于针对哈希表的每个哈希桶生成一个对象，并在哈希桶内存储元素指针；

空间分配子模块，适于分配一个连续的内存空间，并将所述元素指针指向所述连续的内存空间。

B10、根据B8所述的装置，所述连续空间分配模块包括：

分段空间分配子模块，适于在哈希表的每个哈希桶之中，通过slice切片为一个对象分配一个连续的内存空间。

B11、根据B10所述的装置，所述切分空间分配子模块包括：

初始分段空间分配子模块，适于通过make函数对slice切片进行初始化，获得数组内存空间；所述数组内存空间包括多个连续的分段。

B12、根据B11所述的装置，所述元素存储模块包括：

第一存储模块，适于当初始化得到的分段的个数大于等于哈希桶的元素的个数N时，将对应该哈希桶的元素逐个存储到所述分段；

第二存储模块，适于当初始化得到的分段的个数小于哈希桶的元素的个数N时，在存储到初始化的分段中的最后一个分段后，通过append函数逐个添加新的分段并对元素进行存储。

B13、根据B8所述的装置，所述元素包括key和value键值对。

B14、根据B9所述的装置，所述回收模块包括：

释放子模块，适于在对各个元素执行垃圾回收时，释放每个哈希桶对应的内存空间，并将释放所述元素指针。

Claims (14)

1.一种减少golang语言***垃圾回收时间的方法，包括：

在哈希表的每个哈希桶之中，为一个对象分配一个连续的内存空间；

将对应所述哈希桶的各元素存储在所述连续的内存空间中；

在对各个元素执行垃圾回收时，对每个哈希桶之中的对象进行一次性释放。

2.根据权利要求1所述的方法，其特征在于，所述在哈希表的每个哈希桶之中，为一个对象分配一个连续的内存空间，包括：

针对哈希表的每个哈希桶生成一个对象，并在哈希桶内存储元素指针；

分配一个连续的内存空间，并将所述元素指针指向所述连续的内存空间。

3.根据权利要求1所述的方法，其特征在于，所述在哈希表的每个哈希桶之中，为一个对象分配一个连续的内存空间，包括：

在哈希表的每个哈希桶之中，通过slice切片为一个对象分配一个连续的内存空间。

4.根据权利要求3所述的方法，其特征在于，所述在哈希表的每个哈希桶之中，通过slice切片为一个对象分配一个连续的内存空间，包括：

通过make函数对slice切片进行初始化，获得数组内存空间；所述数组内存空间包括N个连续的分段。

5.根据权利要求4所述的方法，其特征在于，所述将对应所述哈希桶的各元素存储在所述连续的内存空间中，包括：

当初始化得到的分段的个数大于等于哈希桶的元素的个数N时，将对应该哈希桶的元素逐个存储到所述分段；

当初始化得到的分段的个数小于哈希桶的元素的个数N时，在存储到初始化的分段中的最后一个分段后，通过append函数逐个添加新的分段并对元素进行存储。

6.根据权利要求1所述的方法，其特征在于，所述元素包括key和value键值对。

7.根据权利要求2所述的方法，其特征在于，所述在对各个元素执行垃圾回收时，对每个哈希桶之中的对象进行一次性释放，包括：

在对各个元素执行垃圾回收时，释放每个哈希桶对应的内存空间，并释放所述元素指针。

8.一种减少golang语言***垃圾回收时间的装置，包括：

连续空间分配模块，适于对于哈希表的每个哈希桶，为所述哈希桶分配一个连续的内存空间；

元素存储模块，适于将对应所述哈希桶的各元素存储在所述连续的内存空间中；

回收模块，适于在对各个元素执行垃圾回收时，对每个哈希桶之中的对象进行一次性释放。

9.根据权利要求8所述的装置，其特征在于，所述连续空间分配模块包括：

指针存储子模块，适于针对哈希表的每个哈希桶生成一个对象，并在哈希桶内存储元素指针；

空间分配子模块，适于分配一个连续的内存空间，并将所述元素指针指向所述连续的内存空间。

10.根据权利要求8所述的装置，其特征在于，所述连续空间分配模块包括：

分段空间分配子模块，适于在哈希表的每个哈希桶之中，通过slice切片为一个对象分配一个连续的内存空间。

11.根据权利要求10所述的装置，其特征在于，所述分段空间分配子模块包括：

初始分段空间分配子模块，适于通过make函数对slice切片进行初始化，获得数组内存空间；所述数组内存空间包括多个连续的分段。

12.根据权利要求11所述的装置，其特征在于，所述元素存储模块包括：

第一存储模块，适于当初始化得到的分段的个数大于等于哈希桶的元素的个数N时，将对应该哈希桶的元素逐个存储到所述分段；

第二存储模块，适于当初始化得到的分段的个数小于哈希桶的元素的个数N时，在存储到初始化的分段中的最后一个分段后，通过append函数逐个添加新的分段并对元素进行存储。

13.根据权利要求8所述的装置，其特征在于，所述元素包括key和value键值对。

14.根据权利要求9所述的装置，其特征在于，所述回收模块包括：

释放子模块，适于在对各个元素执行垃圾回收时，释放每个哈希桶对应的内存空间，并将释放所述元素指针。

Images