CN104102693A - 对象处理方法和装置 - Google Patents

Abstract

本发明公开了一种对象处理方法和装置，属于计算机技术领域。所述方法包括：从接收队列中获取一个对象；从至少一个处理单元中为对象分配一个处理单元；获取为对象分配的处理单元的负载；若负载大于缓存阈值，则将对象添加至缓存队列中；根据缓存队列对对象进行延迟处理。解决了背景技术中当大量的请求同时需要某一具有Redis端口的Redis实例进行处理时，所导致的请求积压、请求超时、业务访问不可用的问题；当某一处理单元(比如具有Redis端口的Redis实例)的负载过高时，将接收队列中对应于该处理单元的对象添加至缓存队列后再对其进行延迟处理，避免了在接收队列中造成积压的问题，隔离了对应于不同处理单元的对象的相互影响，保证了处理速度。

Description

对象处理方法和装置

技术领域

本发明涉及计算机技术领域，特别涉及一种对象处理方法和装置。

背景技术

Redis是一个开源、支持网络、基于内存的key-value(键值对)数据库。Redis支持存储的数据类型包括string(字符串)、list(链表)、set(集合)、zset(有序集合)和hash(哈希类型)等。在对Redis数据库进行访问的过程中，大致可分为读请求和写请求两种。

请参考图1，其示出了对Redis数据库进行访问所涉及的示意图。以读请求为例，m个读请求存放于请求队列12中，m≥1。为了应对大规模的业务访问，需要部署多个Redis实例14，每个Redis实例14占用一个Redis端口。请求队列12中的读请求由该请求队列12对应的n个线程进行处理，n≥1。对于任一读请求，系统随机分配一个线程进行处理。假设线程1对读请求m进行处理，则线程1读取读请求m的key，并通过哈希算法将key映射到多个Redis端口中的一个，进而通过该Redis端口将读请求下发至与其对应的Redis实例14，并通过该Redis实例14对该读请求进行处理。比如，该Redis实例14可以提供读取数据文件的功能。

在实现本发明的过程中，发明人发现上述技术至少存在以下问题：当请求队列12中存放的m个读请求的key哈希分布不均匀，或者在某个时间段内存在大量的具有相同的key的读请求时，将会导致某一Redis端口对应的Redis实例的负载过高。由于Redis实例只支持对读请求进行单线程地串行处理，这就导致无法对大量的读请求进行及时地处理，造成请求积压、请求超时、业务访问不可用的问题。类似的，针对写请求的处理，上述技术也存在同样的问题。

发明内容

为了解决上述技术中存在的当大量的请求同时需要某一具有Redis端口的Redis实例进行处理时，所导致的请求积压、请求超时、业务访问不可用的问题，本发明实施例提供了一种对象处理方法和装置。所述技术方案如下：

第一方面，提供了一种对象处理方法，用于服务器中，所述方法包括：

从接收队列中获取一个对象；其中，所述接收队列中保存有来自至少一个客户端的待处理的对象，所述对象为请求或者消息；

从至少一个处理单元中为所述对象分配一个处理单元；

获取为所述对象分配的所述处理单元的负载；

若所述负载大于缓存阈值，则将所述对象添加至缓存队列中；

根据所述缓存队列对所述对象进行延迟处理。

可选的，所述根据所述缓存队列对所述对象进行延迟处理，包括：

从所述缓存队列中获取所述对象；

再次获取为所述对象分配的所述处理单元的负载；

根据所述负载对所述对象进行处理或者将所述对象进行丢弃。

可选的，所述根据所述负载对所述对象进行处理或者将所述对象进行丢弃，包括：

判断所述负载是否小于第一预定阈值；

若所述负载小于所述第一预定阈值，则通过为所述对象分配的所述处理单元对所述对象进行处理；

若所述负载大于所述第一预定阈值，则将所述对象进行丢弃。

可选的，所述根据所述负载对所述对象进行处理或者将所述对象进行丢弃，包括：

判断所述负载与第二预定阈值和第三预定阈值的大小关系，所述第二预定阈值小于所述第三预定阈值；

若所述负载小于所述第二预定阈值，则通过为所述对象分配的所述处理单元对所述对象进行处理；

若所述负载大于所述第二预定阈值但小于所述第三预定阈值，则将所述对象进行随机性丢弃；

若所述负载大于所述第三预定阈值，则将所述对象进行丢弃。

可选的，所述将所述对象进行随机性丢弃，包括：

根据所述第二预定阈值和所述第三预定阈值计算丢弃概率P，0＜P＜1；

根据所述丢弃概率P确定是否将所述对象进行丢弃；

若确定将所述对象进行丢弃，则执行所述将所述对象进行丢弃的步骤。

可选的，所述根据所述第二预定阈值和所述第三预定阈值计算丢弃概率P，包括：

当所述处理单元的负载由所述处理单元的平均处理时长T_avg表示时，根据所述第二预定阈值T_min和所述第三预定阈值T_max计算所述丢弃概率P：

$P=P_{\max }\×\frac{T_{\mathrm{avg}}-T_{\min }}{T_{\max }-T_{\min }};$

其中，a为预设常数且2^a＞T_max-T_min，所述平均处理时长T_avg用于反映所述处理单元对各个历史对象进行处理时所需耗费的时长，T_avg≥0。

可选的，所述根据所述丢弃概率P确定是否将所述对象进行丢弃，包括：

获取从上一次将对象进行丢弃的时刻开始进入所述接收队列，且与所述对象分配至相同的处理单元的对象的数量N，N≥0；

计算第一随机数并随机生成第二随机数R₂，0＜R₂＜1；

比较所述第一随机数R₁与所述第二随机数R₂的大小；

若R₁≥R₂，则确定将所述对象进行丢弃；

若R₁＜R₂，则确定不将所述对象进行丢弃。

可选的，所述从至少一个处理单元中为所述对象分配一个处理单元，包括：

当所述对象为用于访问Redis数据库的请求，且所述至少一个处理单元为所述Redis数据库对应的至少一个具有Redis端口的Redis实例时，获取所述请求的key；

通过哈希算法将所述请求的key映射至所述至少一个具有Redis端口的Redis实例中的一个，映射至的具有Redis端口的Redis实例是为所述请求分配的所述处理单元。

可选的，所述通过为所述对象分配的所述处理单元对所述对象进行处理，包括：

通过为所述请求分配的具有Redis端口的Redis实例对所述请求进行处理。

第二方面，提供了一种对象处理装置，用于服务器中，所述装置包括：

对象获取模块，用于从接收队列中获取一个对象；其中，所述接收队列中保存有来自至少一个客户端的待处理的对象，所述对象为请求或者消息；

单元分配模块，用于从至少一个处理单元中为所述对象分配一个处理单元；

负载获取模块，用于获取为所述对象分配的所述处理单元的负载；

对象添加模块，用于若所述负载大于缓存阈值，则将所述对象添加至缓存队列中；

延迟处理模块，用于根据所述缓存队列对所述对象进行延迟处理。

可选的，所述延迟处理模块，包括：对象获取子模块、负载获取子模块和对象处理子模块；

所述对象获取子模块，用于从所述缓存队列中获取所述对象；

所述负载获取子模块，用于再次获取为所述对象分配的所述处理单元的负载；

所述对象处理子模块，用于根据所述负载对所述对象进行处理或者将所述对象进行丢弃。

可选的，所述对象处理子模块，包括：第一判断单元、对象处理单元和对象丢弃单元；

所述第一判断单元，用于判断所述负载是否小于第一预定阈值；

所述对象处理单元，用于若所述负载小于所述第一预定阈值，则通过为所述对象分配的所述处理单元对所述对象进行处理；

所述对象丢弃单元，用于若所述负载大于所述第一预定阈值，则将所述对象进行丢弃。

可选的，所述对象处理子模块，包括：第二判断单元、对象处理单元、随机丢弃单元和对象丢弃单元；

所述第二判断单元，用于判断所述负载与第二预定阈值和第三预定阈值的大小关系，所述第二预定阈值小于所述第三预定阈值；

所述对象处理单元，用于若所述负载小于所述第二预定阈值，则通过为所述对象分配的所述处理单元对所述对象进行处理；

所述随机丢弃单元，用于若所述负载大于所述第二预定阈值但小于所述第三预定阈值，则将所述对象进行随机性丢弃；

所述对象丢弃单元，用于若所述负载大于所述第三预定阈值，则将所述对象进行丢弃。

可选的，所述随机丢弃单元，包括：概率计算子单元、丢弃确定子单元和对象丢弃子单元；

所述概率计算子单元，用于根据所述第二预定阈值和所述第三预定阈值计算丢弃概率P，0＜P＜1；

所述丢弃确定子单元，用于根据所述丢弃概率P确定是否将所述对象进行丢弃；

所述对象丢弃子单元，用于若确定将所述对象进行丢弃，则将所述对象进行丢弃。

可选的，所述概率计算子单元，还用于当所述处理单元的负载由所述处理单元的平均处理时长T_avg表示时，根据所述第二预定阈值T_min和所述第三预定阈值T_max计算所述丢弃概率P：

$P=P_{\max }\×\frac{T_{\mathrm{avg}}-T_{\min }}{T_{\max }-T_{\min }};$

其中，a为预设常数且2^a＞T_max-T_min，所述平均处理时长T_avg用于反映所述处理单元对各个历史对象进行处理时所需耗费的时长，T_avg≥0。

可选的，所述丢弃确定子单元，包括：获取子单元、计算子单元、比较子单元、丢弃子单元和不丢弃子单元；

所述获取子单元，用于获取从上一次将对象进行丢弃的时刻开始进入所述接收队列，且与所述对象分配至相同的处理单元的对象的数量N，N≥0；

所述计算子单元，用于计算第一随机数并随机生成第二随机数R₂，0＜R₂＜1；

所述比较子单元，用于比较所述第一随机数R₁与所述第二随机数R₂的大小；

所述丢弃子单元，用于若R₁≥R₂，则确定将所述对象进行丢弃；

所述不丢弃子单元，用于若R₁＜R₂，则确定不将所述对象进行丢弃。

可选的，所述单元分配模块，包括：获取子模块和映射子模块；

所述获取子模块，用于当所述对象为用于访问Redis数据库的请求，且所述至少一个处理单元为所述Redis数据库对应的至少一个具有Redis端口的Redis实例时，获取所述请求的key；

所述映射子模块，用于通过哈希算法将所述请求的key映射至所述至少一个具有Redis端口的Redis实例中的一个，映射至的具有Redis端口的Redis实例是为所述请求分配的所述处理单元。

可选的，所述对象处理单元，还用于通过为所述请求分配的具有Redis端口的Redis实例对所述请求进行处理。

本发明实施例提供的技术方案带来的有益效果是：

通过从至少一个处理单元中为待处理的对象分配一个处理单元，并获取为对象分配的处理单元的负载，若负载大于缓存阈值，则将对象添加至缓存队列中，然后根据缓存队列对对象进行延迟处理；解决了背景技术中存在的当大量的请求同时需要某一具有Redis端口的Redis实例进行处理时，所导致的请求积压、请求超时、业务访问不可用的问题；当某一处理单元(比如具有Redis端口的Redis实例)的负载过高时，将接收队列中对应于该处理单元的对象添加至缓存队列中缓存一段时间后，再对其进行延迟处理，避免了在接收队列中造成请求或者消息的积压，隔离了对应于不同处理单元的对象之间的相互影响，保证了对接收队列中对象的处理速度。

附图说明

为了更清楚地说明本发明实施例中的技术方案，下面将对实施例描述中所需要使用的附图作简单地介绍，显而易见地，下面描述中的附图仅仅是本发明的一些实施例，对于本领域普通技术人员来讲，在不付出创造性劳动的前提下，还可以根据这些附图获得其他的附图。

图1是对Redis数据库进行访问所涉及的示意图；

图2是本发明各个实施例所涉及的实施环境的结构示意图；

图3是本发明一个实施例提供的对象处理方法的方法流程图；

图4A是本发明另一实施例提供的对象处理方法的方法流程图；

图4B是通过本发明实施例提供的对象处理方法对Redis数据库进行访问所涉及的示意图；

图5是本发明一个实施例提供的对象处理装置的结构方框图；

图6是本发明另一实施例提供的对象处理装置的结构方框图；

图7是本发明一个实施例提供的服务器的结构示意图。

具体实施方式

为使本发明的目的、技术方案和优点更加清楚，下面将结合附图对本发明实施方式作进一步地详细描述。

请参考图2，其示出了本发明各个实施例所涉及的实施环境的结构示意图。该实施环境包括至少一个终端210和服务器220。

终端210可以是手机、平板电脑、电子书阅读器、MP3(Moving Picture ExpertsGroup Audio Layer III，动态影像专家压缩标准音频层面3)播放器、MP4(MovingPicture Experts Group Audio Layer IV，动态影像专家压缩标准音频层面4)播放器、膝上型便携计算机和台式计算机等等。

终端210中运行有客户端，客户端用于通过无线网络或者有线网络向服务器220发送待处理的对象。该对象可以是请求，也可以是消息。

服务器220可以是一台服务器，或者由若干台服务器组成的服务器集群，或者是一个云计算服务中心。服务器220用于接收终端210中运行的客户端发送的对象，并将对象保存至接收队列中。其中，当对象为请求时，对应的接收队列可以称为请求队列；当对象为消息时，对应的接收队列可以称为消息队列。

请参考图3，其示出了本发明一个实施例提供的对象处理方法的方法流程图，本实施例以该对象处理方法应用于图2所示实施环境中的服务器侧来举例说明。该对象处理方法可以包括如下几个步骤：

步骤302，从接收队列中获取一个对象；其中，接收队列中保存有来自至少一个客户端的待处理的对象，该对象为请求或者消息。

步骤304，从至少一个处理单元中为对象分配一个处理单元。

步骤306，获取为对象分配的处理单元的负载。

步骤308，若负载大于缓存阈值，则将对象添加至缓存队列中。

步骤310，根据缓存队列对对象进行延迟处理。

综上所述，本实施例提供的对象处理方法，通过从至少一个处理单元中为待处理的对象分配一个处理单元，并获取为对象分配的处理单元的负载，若负载大于缓存阈值，则将对象添加至缓存队列中，然后根据缓存队列对对象进行延迟处理；解决了背景技术中存在的当大量的请求同时需要某一具有Redis端口的Redis实例进行处理时，所导致的请求积压、请求超时、业务访问不可用的问题；当某一处理单元(比如具有Redis端口的Redis实例)的负载过高时，将接收队列中对应于该处理单元的对象添加至缓存队列中缓存一段时间后，再对其进行延迟处理，避免了在接收队列中造成请求或者消息的积压，隔离了对应于不同处理单元的对象之间的相互影响，保证了对接收队列中对象的处理速度。

请参考图4A，其示出了本发明另一实施例提供的对象处理方法的方法流程图，本实施例以该对象处理方法应用于图2所示实施环境中的服务器侧来举例说明。该对象处理方法可以包括如下几个步骤：

步骤401，从接收队列中获取一个对象。

接收队列中保存有来自至少一个客户端的待处理的对象，该对象为请求或者消息。其中，当对象为请求时，对应的接收队列可以称为请求队列；当对象为消息时，对应的接收队列可以称为消息队列。服务器通常按照先进先出的原则从接收队列中按序获取一个对象。

请参考图4B，其示出了通过本实施例提供的对象处理方法对Redis数据库进行访问所涉及的示意图。接收队列41中包含至少一个待处理的请求，该至少一个待处理的请求用于对Redis数据库进行访问。其中，当接收队列41中包含的为读请求时，接收队列41可以称为读请求队列；当接收队列41中包含的为写请求时，接收队列41可以称为写请求队列。

步骤402，从至少一个处理单元中为对象分配一个处理单元。

接收队列对应于至少一个用于处理对象的处理单元。在Redis中，该处理单元即为用于处理请求的具有Redis端口的Redis实例。服务器可以通过哈希算法或者其它算法为对象分配一个处理单元。

比如，在Redis中，由于Redis是key-value数据库，每一个用于访问Redis数据库的请求都携带有一个key，线程从接收队列中读取请求后，获取请求的key，并通过哈希算法将key映射至至少一个具有Redis端口的Redis实例中的一个，该映射至的具有Redis端口的Redis实例是为该请求分配的处理单元。

步骤403，获取为对象分配的处理单元的负载。

一个处理单元的负载能够反映该处理单元的处理能力。当处理单元的负载较高时，表明其所需要处理的对象较多，其相应的处理能力将会下降；反之，当处理单元的负载较低时，表明其所需要处理的对象较少，其相应的处理能力将会提高。

可选的，处理单元的负载可以由处理单元的平均处理时长T_avg表示，平均处理时长T_avg用于反映处理单元对各个历史对象进行处理时所需耗费的时长，T_avg≥0。某一处理单元的平均处理时长T_avg越大，表明该处理单元对历史对象进行处理时所需耗费的时长较长，也即该处理单元的负载较高；反之，某一处理单元的平均处理时长T_avg越小，表明该处理单元对历史对象进行处理时所需耗费的时长较短，也即该处理单元的负载较低。

步骤404，若负载大于缓存阈值，则将对象添加至缓存队列中。

缓存阈值为预先设定的值。当处理单元的负载由处理单元的平均处理时长T_avg表示时，缓存阈值可记为T_normal。服务器获取为对象分配的处理单元的平均处理时长T_avg之后，判断平均处理时长T_avg与缓存阈值T_normal之间的大小关系；若0≤T_avg≤T_normal，则直接通过为对象分配的处理单元对对象进行处理；若T_avg＞T_normal，则将对象添加至缓存队列中。缓存队列用于将对象缓存一段时间，服务器通过缓存队列的缓存对对象进行延迟处理。

可选的，服务器还可以根据处理单元的负载确定处理单元的服务级别。当处理单元的负载小于或者等于缓存阈值时，服务器确定处理单元的服务级别为正常级别，表明该处理单元的负载较低，可以对对象正常进行处理。当处理单元的负载大于缓存阈值时，服务器确定处理单元的服务级别不是正常级别，表明该处理单元的负载较高，若继续将对象下发至该处理单元进行处理，可能导致处理速度过慢、无响应以及接收队列中的其它对象的积压等问题。进一步地，当确定出处理单元的服务级别不是正常级别时，服务器将对象添加至缓存队列中。

如图4B所示，假设系统分配线程n对接收队列41中的请求m进行处理，线程n从接收队列41中读取请求m后，获取该请求对应的具有Redis端口的Redis实例42的平均处理时长T_avg，并检测T_avg是否大于T_normal；当T_avg＞T_normal时，线程n将请求m添加至缓存队列43中，并后续由缓存队列43对应的多线程对请求m进行处理。

步骤405，从缓存队列中获取对象。

对象进入缓存队列后，仍然按照先进先出的原则被逐一按序处理。

如图4B所示，假设系统分配线程k为缓存队列43中的请求m进行处理，线程k从缓存队列43中读取请求m。

步骤406，再次获取为对象分配的处理单元的负载。

待处理的对象经过在缓存队列中的一段时间的等待之后，为该对象分配的处理单元的服务级别可能发生变化，此时需要再次获取为该对象分配的处理单元的负载。

可选的，服务器再次获取处理单元的平均处理时长T_avg。

步骤407，根据负载对对象进行处理或者将对象进行丢弃。

在第一种可能的实现方式中，本步骤可以包括如下几个子步骤：

第一，判断负载是否小于第一预定阈值。

第一预定阈值为预先设定的值。当处理单元的负载由处理单元的平均处理时长T_avg表示时，第一预定阈值可记为T₁。优选的，第一预定阈值T₁大于或者等于缓存阈值T_normal。

第二，若负载小于第一预定阈值，则通过为对象分配的处理单元对对象进行处理。

第三，若负载大于第一预定阈值，则将对象进行丢弃。

服务器再次获取处理单元的平均处理时长T_avg之后，判断再次获取的平均处理时长T_avg与第一预定阈值T₁之间的大小关系；若0≤T_avg≤T₁，则通过为对象分配的处理单元对对象进行处理；若T_avg＞T₁，则将对象进行丢弃。

在第二种可能的实现方式中，本步骤可以包括如下几个子步骤：

第一，判断负载与第二预定阈值和第三预定阈值的大小关系。

其中，第二预定阈值和第三预定阈值均为预先设定的值，且第二预定阈值小于第三预定阈值。当处理单元的负载由处理单元的平均处理时长T_avg表示时，第二预定阈值可记为T_min，第三预定阈值可记为T_max。优选的，第二预定阈值T_min大于或者等于缓存阈值T_normal。

第二，若负载小于第二预定阈值，则通过为对象分配的处理单元对对象进行处理。

当负载小于第二预定阈值时，线程将待处理的对象下发至为该对象分配的处理单元，并通过该处理单元对对象进行处理。比如，通过为请求分配的具有Redis端口的Redis实例对请求进行处理，该Redis实例可以提供读取数据文件或者写入数据文件等功能。

第三，若负载大于第二预定阈值但小于第三预定阈值，则将对象进行随机性丢弃。

当负载大于第二预定阈值但小于第三预定阈值时，随机性地确定是否将对象进行丢弃。在一种可能的实施方式中，本步骤可以包括：

1、根据第二预定阈值和第三预定阈值计算丢弃概率P，0＜P＜1。

当处理单元的负载由处理单元的平均处理时长T_avg表示时，根据第二预定阈值T_min和第三预定阈值T_max计算丢弃概率P：

$P=P_{\max }\×\frac{T_{\mathrm{avg}}-T_{\min }}{T_{\max }-T_{\min }};$

其中，a为预设常数且2^a＞T_max-T_min。

2、根据丢弃概率P确定是否将对象进行丢弃。

(1)获取从上一次将对象进行丢弃的时刻开始进入接收队列，且与对象分配至相同的端处理单元的对象的数量N，N≥0。

N反映了最近一段时间内进入接收队列中，且同类型的待处理的对象(比如具有相同的key的待处理的请求)的数量情况。

(2)计算第一随机数并随机生成第二随机数R₂，0＜R₂＜1。

N越大，第一随机数R₁越大；反之，N越小，第一随机数R₁越小。通过上述公式计算得的第一随机数R₁能够更为准确地反映出为对象分配的处理单元的负载情况。

(3)比较第一随机数R₁与第二随机数R₂的大小。

(4)若R₁≥R₂，则确定将对象进行丢弃。

(5)若R₁＜R₂，则确定不将对象进行丢弃。

3、若确定将对象进行丢弃，则将对象进行丢弃。

另外，若确定不将对象进行丢弃，则将对象再次添加至缓存队列中，并重复上述步骤405至步骤407对该对象进行处理。

第四，若负载大于第三预定阈值，则将对象进行丢弃。

通过将对象进行丢弃，可以有效地缓解为对象分配的处理单元的负载压力，使得各个处理单元的处理能力得到有效的平衡，避免因某个处理单元的处理能力大幅下降而影响到接收队列中其它待处理的对象通过其它处理单元对目标进行访问，有效避免了队列的积压阻塞问题。

可选的，服务器还可以根据处理单元的负载确定处理单元的服务级别。以处理单元的负载由处理单元的平均处理时长T_avg表示为例。当0≤T_avg≤T_normal时，将处理单元的服务级别确定为正常级别；当T_normal＜T_avg≤T_min时，将处理单元的服务级别确定为慢级别；当T_min＜T_avg≤T_max时，将处理单元的服务级别确定为随机丢包级别；当T_avg＞T_max时，将处理单元的服务级别确定为丢包级别。服务器依据平均处理时长T_avg的逐步递增，将处理单元的服务级别划分为正常级别、慢级别、随机丢包级别和丢包级别。处理单元的负载量随上述四种不同类型的服务级别依次递增。

对应于上述不同的服务级别，当服务级别为正常级别或者慢级别时，服务器通过为对象分配的处理单元对对象进行处理；当服务级别为随机丢包级别时，服务器将对象进行随机性丢弃；当服务级别为丢包级别时，服务器将对象进行丢弃。

另外，在将对象进行丢弃之后，服务器可以向该对象的发起方，也即向该对象对应的客户端发送处理失败响应。以此告知客户端，服务器并未成功处理其发送的对象，客户端可以依据该处理失败响应在后续的某个时刻再次向服务器发送该处理失败的对象。

类似的，在通过为对象分配的处理单元对对象进行处理之后，服务器可以向该对象的发起方，也即向该对象对应的客户端发送处理成功响应。以此告知客户端，服务器已成功处理其发送的对象。

另外，当处理单元的负载由处理单元的平均处理时长T_avg表示时，本实施例还提供了一种对处理单元的平均处理时长T_avg的更新机制。具体的：

不论是将对象进行丢弃之后，或者通过为对象分配的处理单元对对象进行处理之后，记录对象的处理时间t，并更新为对象分配的处理单元的平均处理时长T_avg。若将对象进行丢弃，则将对象的处理时间t记为0；若为对象分配的处理单元对对象进行处理，则依据实际处理情况记录对象的处理时间t，t＞0。

之后，通过加权平均算法对服务单元的平均处理时长T_avg进行更新。更新后的平均处理时长T_avg'＝(1-w)×T_avg+w×t；其中，T_avg为更新前的平均处理时长，w为预设权重且0＜w＜1。

当t＞T_avg时，更新后的平均处理时长T_avg'将会增大；当t＜T_avg时，更新后的平均处理时长T_avg'将会减小。特别地，在将对象进行丢弃的情况下，将对象的处理时间t记为0，可以使得该对象对应的处理单元的平均处理时长逐渐下降，直至恢复至小于或者等于缓存阈值，由此保证不会长时间地进行丢弃。

综上所述，本实施例提供的对象处理方法，通过从至少一个处理单元中为待处理的对象分配一个处理单元，并获取为对象分配的处理单元的负载，若负载大于缓存阈值，则将对象添加至缓存队列中，然后根据缓存队列对对象进行延迟处理；解决了背景技术中存在的当大量的请求同时需要某一具有Redis端口的Redis实例进行处理时，所导致的请求积压、请求超时、业务访问不可用的问题；当某一处理单元(比如具有Redis端口的Redis实例)的负载过高时，将接收队列中对应于该处理单元的对象添加至缓存队列中缓存一段时间后，再对其进行延迟处理，避免了在接收队列中造成请求或者消息的积压，隔离了对应于不同处理单元的对象之间的相互影响，保证了对接收队列中对象的处理速度。

另外，本实施例提供的对象处理方法，还通过设定不同的阈值，选择性地将缓存队列中的对象进行处理或者丢弃。通过将对象进行丢弃，可以有效地缓解该对象对应的处理单元的负载压力，使得各个处理单元的处理能力得到有效的平衡，避免因某个处理单元的处理能力大幅下降而影响到接收队列中其它待处理的对象通过其它处理单元对目标进行访问，有效避免了队列的积压阻塞问题。

下述为本发明装置实施例，可以用于执行本发明方法实施例。对于本发明装置实施例中未披露的细节，请参照本发明方法实施例。

请参考图5，其示出了本发明一个实施例提供的对象处理装置的结构方框图，该对象处理装置可以通过软件、硬件或者两者的结合实现成为服务器的部分或者全部。该对象处理装置可以包括：对象获取模块510、单元分配模块520、负载获取模块530、对象添加模块540和延迟处理模块550。

对象获取模块510，用于从接收队列中获取一个对象；其中，所述接收队列中保存有来自至少一个客户端的待处理的对象，所述对象为请求或者消息。

单元分配模块520，用于从至少一个处理单元中为所述对象分配一个处理单元。

负载获取模块530，用于获取为所述对象分配的所述处理单元的负载。

对象添加模块540，用于若所述负载大于缓存阈值，则将所述对象添加至缓存队列中。

延迟处理模块550，用于根据所述缓存队列对所述对象进行延迟处理。

综上所述，本实施例提供的对象处理装置，通过从至少一个处理单元中为待处理的对象分配一个处理单元，并获取为对象分配的处理单元的负载，若负载大于缓存阈值，则将对象添加至缓存队列中，然后根据缓存队列对对象进行延迟处理；解决了背景技术中存在的当大量的请求同时需要某一具有Redis端口的Redis实例进行处理时，所导致的请求积压、请求超时、业务访问不可用的问题；当某一处理单元(比如具有Redis端口的Redis实例)的负载过高时，将接收队列中对应于该处理单元的对象添加至缓存队列中缓存一段时间后，再对其进行延迟处理，避免了在接收队列中造成请求或者消息的积压，隔离了对应于不同处理单元的对象之间的相互影响，保证了对接收队列中对象的处理速度。

请参考图6，其示出了本发明一个实施例提供的对象处理装置的结构方框图，该对象处理装置可以通过软件、硬件或者两者的结合实现成为服务器的部分或者全部。该对象处理装置可以包括：对象获取模块510、单元分配模块520、负载获取模块530、对象添加模块540和延迟处理模块550。

对象获取模块510，用于从接收队列中获取一个对象；其中，所述接收队列中保存有来自至少一个客户端的待处理的对象，所述对象为请求或者消息。

单元分配模块520，用于从至少一个处理单元中为所述对象分配一个处理单元。

可选的，所述单元分配模块520，包括：获取子模块和映射子模块。

所述获取子模块，用于当所述对象为用于访问Redis数据库的请求，且所述至少一个处理单元为所述Redis数据库对应的至少一个具有Redis端口的Redis实例时，获取所述请求的key。

所述映射子模块，用于通过哈希算法将所述请求的key映射至所述至少一个具有Redis端口的Redis实例中的一个，映射至的具有Redis端口的Redis实例是为所述请求分配的所述处理单元。

负载获取模块530，用于获取为所述对象分配的所述处理单元的负载。

对象添加模块540，用于若所述负载大于缓存阈值，则将所述对象添加至缓存队列中。

延迟处理模块550，用于根据所述缓存队列对所述对象进行延迟处理。

所述延迟处理模块550，包括：对象获取子模块550a、负载获取子模块550b和对象处理子模块550c。

所述对象获取子模块550a，用于从所述缓存队列中获取所述对象。

所述负载获取子模块550b，用于再次获取为所述对象分配的所述处理单元的负载。

所述对象处理子模块550c，用于根据所述负载对所述对象进行处理或者将所述对象进行丢弃。

在一种可能的实现方式中，所述对象处理子模块550c，包括：第一判断单元550c1、对象处理单元550c2和对象丢弃单元550c3。

所述第一判断单元550c1，用于判断所述负载是否小于第一预定阈值。

所述对象处理单元550c2，用于若所述负载小于所述第一预定阈值，则通过为所述对象分配的所述处理单元对所述对象进行处理。

所述对象丢弃单元550c3，用于若所述负载大于所述第一预定阈值，则将所述对象进行丢弃。

在另一种可能的实现方式中，所述对象处理子模块550c，包括：第二判断单元550c4、对象处理单元550c2、随机丢弃单元550c5和对象丢弃单元550c3。

所述第二判断单元550c4，用于判断所述负载与第二预定阈值和第三预定阈值的大小关系，所述第二预定阈值小于所述第三预定阈值。

所述对象处理单元550c2，用于若所述负载小于所述第二预定阈值，则通过为所述对象分配的所述处理单元对所述对象进行处理。

可选的，当所述对象为用于访问Redis数据库的请求，且所述至少一个处理单元为所述Redis数据库对应的至少一个具有Redis端口的Redis实例时，所述对象处理单元550c2，还用于通过为所述请求分配的具有Redis端口的Redis实例对所述请求进行处理。

所述随机丢弃单元550c5，用于若所述负载大于所述第二预定阈值但小于所述第三预定阈值，则将所述对象进行随机性丢弃。

所述随机丢弃单元550c5，包括：概率计算子单元、丢弃确定子单元和对象丢弃子单元。

所述概率计算子单元，用于根据所述第二预定阈值和所述第三预定阈值计算丢弃概率P，0＜P＜1。

可选的，所述概率计算子单元，还用于当所述处理单元的负载由所述处理单元的平均处理时长T_avg表示时，根据所述第二预定阈值T_min和所述第三预定阈值T_max计算所述丢弃概率P：

$P=P_{\max }\×\frac{T_{\mathrm{avg}}-T_{\min }}{T_{\max }-T_{\min }};$

其中，a为预设常数且2^a＞T_max-T_min，所述平均处理时长T_avg用于反映所述处理单元对各个历史对象进行处理时所需耗费的时长，T_avg≥0。

所述丢弃确定子单元，用于根据所述丢弃概率P确定是否将所述对象进行丢弃。

可选的，所述丢弃确定子单元，包括：获取子单元、计算子单元、比较子单元、丢弃子单元和不丢弃子单元。

所述获取子单元，用于获取从上一次将对象进行丢弃的时刻开始进入所述接收队列，且与所述对象分配至相同的处理单元的对象的数量N，N≥0。

所述计算子单元，用于计算第一随机数并随机生成第二随机数R₂，0＜R₂＜1。

所述比较子单元，用于比较所述第一随机数R₁与所述第二随机数R₂的大小。

所述丢弃子单元，用于若R₁≥R₂，则确定将所述对象进行丢弃。

所述不丢弃子单元，用于若R₁＜R₂，则确定不将所述对象进行丢弃。

所述对象丢弃子单元，用于若确定将所述对象进行丢弃，则将所述对象进行丢弃。

所述对象丢弃单元550c3，用于若所述负载大于所述第三预定阈值，则将所述对象进行丢弃。

综上所述，本实施例提供的对象处理装置，通过从至少一个处理单元中为待处理的对象分配一个处理单元，并获取为对象分配的处理单元的负载，若负载大于缓存阈值，则将对象添加至缓存队列中，然后根据缓存队列对对象进行延迟处理；解决了背景技术中存在的当大量的请求同时需要某一具有Redis端口的Redis实例进行处理时，所导致的请求积压、请求超时、业务访问不可用的问题；当某一处理单元(比如具有Redis端口的Redis实例)的负载过高时，将接收队列中对应于该处理单元的对象添加至缓存队列中缓存一段时间后，再对其进行延迟处理，避免了在接收队列中造成请求或者消息的积压，隔离了对应于不同处理单元的对象之间的相互影响，保证了对接收队列中对象的处理速度。

另外，本实施例提供的对象处理装置，还通过设定不同的阈值，选择性地将缓存队列中的对象进行处理或者丢弃。通过将对象进行丢弃，可以有效地缓解该对象对应的处理单元的负载压力，使得各个处理单元的处理能力得到有效的平衡，避免因某个处理单元的处理能力大幅下降而影响到接收队列中其它待处理的对象通过其它处理单元对目标进行访问，有效避免了队列的积压阻塞问题。

需要说明的是：上述实施例提供的对象处理装置在处理队列中的对象时，仅以上述各功能模块的划分进行举例说明，实际应用中，可以根据需要而将上述功能分配由不同的功能模块完成，即将设备的内部结构划分成不同的功能模块，以完成以上描述的全部或者部分功能。另外，上述实施例提供的对象处理装置与对象处理方法的方法实施例属于同一构思，其具体实现过程详见方法实施例，这里不再赘述。

请参考图7，其示出了本发明一个实施例提供的服务器的结构示意图，该服务器可以用于实施上述实施例中提供的服务器中的对象处理方法。所述服务器700包括中央处理单元(CPU)701、包括随机存取存储器(RAM)702和只读存储器(ROM)703的系统存储器704，以及连接系统存储器704和中央处理单元701的系统总线705。所述服务器700还包括帮助计算机内的各个器件之间传输信息的基本输入/输出系统(I/O系统)706，和用于存储操作系统713、应用程序714和其他程序模块715的大容量存储设备707。

所述基本输入/输出系统706包括有用于显示信息的显示器708和用于用户输入信息的诸如鼠标、键盘之类的输入设备709。其中所述显示器708和输入设备709都通过连接到系统总线705的输入/输出控制器710连接到中央处理单元701。所述基本输入/输出系统706还可以包括输入/输出控制器710以用于接收和处理来自键盘、鼠标、或电子触控笔等多个其他设备的输入。类似地，输入/输出控制器710还提供输出到显示屏、打印机或其他类型的输出设备。

所述大容量存储设备707通过连接到系统总线705的大容量存储控制器(未示出)连接到中央处理单元701。所述大容量存储设备707及其相关联的计算机可读介质为服务器700提供非易失性存储。也就是说，所述大容量存储设备707可以包括诸如硬盘或者CD-ROM驱动器之类的计算机可读介质(未示出)。

不失一般性，所述计算机可读介质可以包括计算机存储介质和通信介质。计算机存储介质包括以用于存储诸如计算机可读指令、数据结构、程序模块或其他数据等信息的任何方法或技术实现的易失性和非易失性、可移动和不可移动介质。计算机存储介质包括RAM、ROM、EPROM、EEPROM、闪存或其他固态存储其技术，CD-ROM、DVD或其他光学存储、磁带盒、磁带、磁盘存储或其他磁性存储设备。当然，本领域技术人员可知所述计算机存储介质不局限于上述几种。上述的系统存储器704和大容量存储设备707可以统称为存储器。

根据本发明的各种实施例，所述服务器700还可以通过诸如因特网等网络连接到网络上的远程计算机运行。也即服务器700可以通过连接在所述系统总线705上的网络接口单元711连接到网络712，或者说，也可以使用网络接口单元711来连接到其他类型的网络或远程计算机系统(未示出)。

所述存储器还包括一个或者一个以上的程序，所述一个或者一个以上程序存储于存储器中，且经配置以由一个或者一个以上中央处理单元701执行。上述一个或者一个以上程序包含用于执行如图3或者图4A所示的对象处理方法的指令。

应当理解的是，在本文中使用的，除非上下文清楚地支持例外情况，单数形式“一个”旨在也包括复数形式。还应当理解的是，在本文中使用的“和/或”是指包括一个或者一个以上相关联地列出的项目的任意和所有可能组合。

上述本发明实施例序号仅仅为了描述，不代表实施例的优劣。

本领域普通技术人员可以理解实现上述实施例的全部或部分步骤可以通过硬件来完成，也可以通过程序来指令相关的硬件完成，所述的程序可以存储于一种计算机可读存储介质中，上述提到的存储介质可以是只读存储器，磁盘或光盘等。

以上所述仅为本发明的较佳实施例，并不用以限制本发明，凡在本发明的精神和原则之内，所作的任何修改、等同替换、改进等，均应包含在本发明的保护范围之内。

Claims (18)

1.一种对象处理方法，其特征在于，用于服务器中，所述方法包括：

从接收队列中获取一个对象；其中，所述接收队列中保存有来自至少一个客户端的待处理的对象，所述对象为请求或者消息；

从至少一个处理单元中为所述对象分配一个处理单元；

获取为所述对象分配的所述处理单元的负载；

若所述负载大于缓存阈值，则将所述对象添加至缓存队列中；

根据所述缓存队列对所述对象进行延迟处理。

2.根据权利要求1所述的方法，其特征在于，所述根据所述缓存队列对所述对象进行延迟处理，包括：

从所述缓存队列中获取所述对象；

再次获取为所述对象分配的所述处理单元的负载；

根据所述负载对所述对象进行处理或者将所述对象进行丢弃。

3.根据权利要求2所述的方法，其特征在于，所述根据所述负载对所述对象进行处理或者将所述对象进行丢弃，包括：

判断所述负载是否小于第一预定阈值；

若所述负载小于所述第一预定阈值，则通过为所述对象分配的所述处理单元对所述对象进行处理；

若所述负载大于所述第一预定阈值，则将所述对象进行丢弃。

4.根据权利要求2所述的方法，其特征在于，所述根据所述负载对所述对象进行处理或者将所述对象进行丢弃，包括：

判断所述负载与第二预定阈值和第三预定阈值的大小关系，所述第二预定阈值小于所述第三预定阈值；

若所述负载小于所述第二预定阈值，则通过为所述对象分配的所述处理单元对所述对象进行处理；

若所述负载大于所述第二预定阈值但小于所述第三预定阈值，则将所述对象进行随机性丢弃；

若所述负载大于所述第三预定阈值，则将所述对象进行丢弃。

5.根据权利要求4所述的方法，其特征在于，所述将所述对象进行随机性丢弃，包括：

根据所述第二预定阈值和所述第三预定阈值计算丢弃概率P，0＜P＜1；

根据所述丢弃概率P确定是否将所述对象进行丢弃；

若确定将所述对象进行丢弃，则执行所述将所述对象进行丢弃的步骤。

6.根据权利要求5所述的方法，其特征在于，所述根据所述第二预定阈值和所述第三预定阈值计算丢弃概率P，包括：

当所述处理单元的负载由所述处理单元的平均处理时长T_avg表示时，根据所述第二预定阈值T_min和所述第三预定阈值T_max计算所述丢弃概率P：

$P=P_{\max }\×\frac{T_{\mathrm{avg}}-T_{\min }}{T_{\max }-T_{\min }};$

其中，a为预设常数且2^a＞T_max-T_min，所述平均处理时长T_avg用于反映所述处理单元对各个历史对象进行处理时所需耗费的时长，T_avg≥0。

7.根据权利要求5所述的方法，其特征在于，所述根据所述丢弃概率P确定是否将所述对象进行丢弃，包括：

获取从上一次将对象进行丢弃的时刻开始进入所述接收队列，且与所述对象分配至相同的处理单元的对象的数量N，N≥0；

计算第一随机数并随机生成第二随机数R₂，0＜R₂＜1；

比较所述第一随机数R₁与所述第二随机数R₂的大小；

若R₁≥R₂，则确定将所述对象进行丢弃；

若R₁＜R₂，则确定不将所述对象进行丢弃。

8.根据权利要求1至7任一所述的方法，其特征在于，所述从至少一个处理单元中为所述对象分配一个处理单元，包括：

当所述对象为用于访问Redis数据库的请求，且所述至少一个处理单元为所述Redis数据库对应的至少一个具有Redis端口的Redis实例时，获取所述请求的key；

通过哈希算法将所述请求的key映射至所述至少一个具有Redis端口的Redis实例中的一个，映射至的具有Redis端口的Redis实例是为所述请求分配的所述处理单元。

9.根据权利要求8所述的方法，其特征在于，所述通过为所述对象分配的所述处理单元对所述对象进行处理，包括：

通过为所述请求分配的具有Redis端口的Redis实例对所述请求进行处理。

10.一种对象处理装置，其特征在于，用于服务器中，所述装置包括：

对象获取模块，用于从接收队列中获取一个对象；其中，所述接收队列中保存有来自至少一个客户端的待处理的对象，所述对象为请求或者消息；

单元分配模块，用于从至少一个处理单元中为所述对象分配一个处理单元；

负载获取模块，用于获取为所述对象分配的所述处理单元的负载；

对象添加模块，用于若所述负载大于缓存阈值，则将所述对象添加至缓存队列中；

延迟处理模块，用于根据所述缓存队列对所述对象进行延迟处理。

11.根据权利要求10所述的装置，其特征在于，所述延迟处理模块，包括：对象获取子模块、负载获取子模块和对象处理子模块；

所述对象获取子模块，用于从所述缓存队列中获取所述对象；

所述负载获取子模块，用于再次获取为所述对象分配的所述处理单元的负载；

所述对象处理子模块，用于根据所述负载对所述对象进行处理或者将所述对象进行丢弃。

12.根据权利要求11所述的装置，其特征在于，所述对象处理子模块，包括：第一判断单元、对象处理单元和对象丢弃单元；

所述第一判断单元，用于判断所述负载是否小于第一预定阈值；

所述对象处理单元，用于若所述负载小于所述第一预定阈值，则通过为所述对象分配的所述处理单元对所述对象进行处理；

所述对象丢弃单元，用于若所述负载大于所述第一预定阈值，则将所述对象进行丢弃。

13.根据权利要求11所述的装置，其特征在于，所述对象处理子模块，包括：第二判断单元、对象处理单元、随机丢弃单元和对象丢弃单元；

所述第二判断单元，用于判断所述负载与第二预定阈值和第三预定阈值的大小关系，所述第二预定阈值小于所述第三预定阈值；

所述对象处理单元，用于若所述负载小于所述第二预定阈值，则通过为所述对象分配的所述处理单元对所述对象进行处理；

所述随机丢弃单元，用于若所述负载大于所述第二预定阈值但小于所述第三预定阈值，则将所述对象进行随机性丢弃；

所述对象丢弃单元，用于若所述负载大于所述第三预定阈值，则将所述对象进行丢弃。

14.根据权利要求13所述的装置，其特征在于，所述随机丢弃单元，包括：概率计算子单元、丢弃确定子单元和对象丢弃子单元；

所述概率计算子单元，用于根据所述第二预定阈值和所述第三预定阈值计算丢弃概率P，0＜P＜1；

所述丢弃确定子单元，用于根据所述丢弃概率P确定是否将所述对象进行丢弃；

所述对象丢弃子单元，用于若确定将所述对象进行丢弃，则将所述对象进行丢弃。

15.根据权利要求14所述的装置，其特征在于，

所述概率计算子单元，还用于当所述处理单元的负载由所述处理单元的平均处理时长T_avg表示时，根据所述第二预定阈值T_min和所述第三预定阈值T_max计算所述丢弃概率P：

$P=P_{\max }\×\frac{T_{\mathrm{avg}}-T_{\min }}{T_{\max }-T_{\min }};$

其中，a为预设常数且2^a＞T_max-T_min，所述平均处理时长T_avg用于反映所述处理单元对各个历史对象进行处理时所需耗费的时长，T_avg≥0。

16.根据权利要求14所述的装置，其特征在于，所述丢弃确定子单元，包括：获取子单元、计算子单元、比较子单元、丢弃子单元和不丢弃子单元；

所述获取子单元，用于获取从上一次将对象进行丢弃的时刻开始进入所述接收队列，且与所述对象分配至相同的处理单元的对象的数量N，N≥0；

所述计算子单元，用于计算第一随机数并随机生成第二随机数R₂，0＜R₂＜1；

所述比较子单元，用于比较所述第一随机数R₁与所述第二随机数R₂的大小；

所述丢弃子单元，用于若R₁≥R₂，则确定将所述对象进行丢弃；

所述不丢弃子单元，用于若R₁＜R₂，则确定不将所述对象进行丢弃。

17.根据权利要求10至16任一所述的装置，其特征在于，所述单元分配模块，包括：获取子模块和映射子模块；

所述获取子模块，用于当所述对象为用于访问Redis数据库的请求，且所述至少一个处理单元为所述Redis数据库对应的至少一个具有Redis端口的Redis实例时，获取所述请求的key；

所述映射子模块，用于通过哈希算法将所述请求的key映射至所述至少一个具有Redis端口的Redis实例中的一个，映射至的具有Redis端口的Redis实例是为所述请求分配的所述处理单元。

18.根据权利要求17所述的装置，其特征在于，

所述对象处理单元，还用于通过为所述请求分配的具有Redis端口的Redis实例对所述请求进行处理。