手机号码去重一千万2秒内，bitmap支持百亿号码，仅耗内存1.2G

465228962

因为朋友再移动外包公司上班，有手机号码去重删选的需要，朋友用的python，也是用的哈希去重方式，大概1000W手机数据去重处理速度在5到6秒左右，于是乎我也想用易语言实现以下，想试下易语言能否实现大数据的处理以及实现速度，论坛各种哈希表试了个便，最终得出结论，速度最快的是ASM哈希表，1000W处理时间在4到5秒之间，可以说是非常的快的了，但是用哈希表在易语言运行存在一个问题，我实测1000W号码占用内存大约是400多M，也就是说易语言最大能处理不过三四千万的数据，由于易语言是32位的，最大支持内存仅1.7G这样，内存占用到达1.7G就会自动程序崩溃，无法处理上亿的手机号码，不论你内存条有10G还是100G，但是易语言程序最大仅支持1.7G，实在是非常的限制。但是单从处理速度而言，论坛大神ASM哈希表确实是效率极高的了。后面网上看到bitmap处理上亿级别的手机号码处理，于是到易语言论坛查了下，发现还没人实现过，那我就来做下把。在特定的数据处理情况下，使用bitmap方式去重效率就会显得比哈希表去重更加高效，不仅速度有极大的提升，内存占用方面，即使999亿的手机号码，也仅仅占用1.2G的内存即可处理，极大的节省内存，能够在低配置的电脑上也能运行起来，具体的就不吹嘘，有兴趣的可以自行百度搜索bitmap了解下

最后上代码，cpu为i7 8700实测1000W手机号码数据用bitmap方式去重耗时1.9秒左右，论坛ASM哈希表方式去重4.5秒左右，一亿手机号码数据用bitmap方式去重耗时31秒左右，论坛ASM哈希表无法处理过大数据因而未知，如有更高效率的欢迎留言交流
处理耗时 包含读入文档，载入数据，去重，最后写出。论坛许多噱头都是只谈去重过程，无视读入和写出过程的评测都是耍流氓行为。

压缩包包含源码，请编译后测试，哈希表去重方式调用的论坛ASM哈希表模块，还有生成手机号码的源码一一附上，有兴趣的可以自己测试下



部分代码展示

  

子程序名	返回值类型	公开	备 注
bitmap执行
参数名	类 型	参考	可空	数组	备 注
分块	整数型

变量名	类 型	静态	数组	备 注
数据	快速字节集对象
数据_汇编	类_快速文本
文件名2	文本型
文件长度	整数型
i	整数型
要替换的字节集	字节集
替换为	字节集
处理进度	整数型
原表项字节集数组	字节集		0
单条号码	字节集
单条号码_数组	文本型		0
单条号码_数组_计次	整数型
第一个号码	字节集
文件号	整数型
Heap	整数型
内存大小	整数型
tempInt	整数型
本线程处理块	整数型
Heap_数组	整数型		0
tempInt_数组	整数型		0
分类文件_数组_计次	整数型
a	字节集
zjj	字节集
单条号码_字节集数组	字节集		0
号码字节集	字节集
aa	整数型
返回状态	整数型
余数	整数型
读入大小	长整数型
总执行	长整数型
线程执行分块开始	长整数型
线程执行分块结束	长整数型
jici_局哈希	整数型
jici_局重复	整数型
分类号	整数型
键	字节集
值	整数型
长整数号码	长整数型
模	整数型
长整数号码1	双精度小数型
新结果	字节型

文件号 ＝ 打开文件 (编辑框1.内容, 1, 1)
余数 ＝ 文件尺寸 ％ 总分块
本线程处理块 ＝ 文件尺寸 ÷ 总分块
总执行 ＝ 0
如果 (分块 ＝ 总分块)
本线程处理块 ＝ 本线程处理块 － 本线程处理块 ％ 13
线程执行分块开始 ＝ 到长整数 ( (分块 － 1) × 本线程处理块)
线程执行分块结束 ＝ 到长整数 (文件尺寸)

本线程处理块 ＝ 本线程处理块 － 本线程处理块 ％ 13
线程执行分块开始 ＝ 到长整数 ( (分块 － 1) × 本线程处理块)
线程执行分块结束 ＝ 到长整数 (分块 × 本线程处理块)
重定义数组 (Heap_数组, 假, 哈希表_分类.取数量 ())
重定义数组 (tempInt_数组, 假, 哈希表_分类.取数量 ())
读入大小 ＝ 13000
内存大小 ＝ 读入大小
循环判断首 ()
如果 (分块 ≠ 1 且 i ≠ 1)
移动读写位置 (文件号, 1, 线程执行分块开始 － 1)
处理进度 ＝ 取读写位置 (文件号)
i ＝ i ＋ 1



如果 (处理进度 ＋ 内存大小 ＞ 线程执行分块结束)
读入大小 ＝ 线程执行分块结束 － 处理进度
内存大小 ＝ 读入大小



数据.置字节集 (读入字节集 (文件号, 内存大小))
处理进度 ＝ 取读写位置 (文件号)
如果 (处理进度 ＜ 线程执行分块开始 或 处理进度 ＞ 线程执行分块结束)
到循环尾 ()



计次循环首 (哈希表_分类.取数量 (), 分类文件_数组_计次)
Heap_数组 [分类文件_数组_计次] ＝ HeapAlloc (g_ProcessHeap, 0, 内存大小)
tempInt_数组 [分类文件_数组_计次] ＝ Heap_数组 [分类文件_数组_计次]
计次循环尾 ()
' ===================
单条号码_字节集数组 ＝ 数据.分割字节集 ({ 13, 10, 49 }, )
单条号码_字节集数组 [1] ＝ 取字节集右边 (单条号码_字节集数组 [1], 10)
如果 (取字节集长度 (取字节集左边 (单条号码_字节集数组 [取数组成员数 (单条号码_字节集数组)], 10)) ＜ 10)
删除成员 (单条号码_字节集数组, 取数组成员数 (单条号码_字节集数组), )

单条号码_字节集数组 [取数组成员数 (单条号码_字节集数组)] ＝ 取字节集左边 (单条号码_字节集数组 [取数组成员数 (单条号码_字节集数组)], 10)

计次循环首 (取数组成员数 (单条号码_字节集数组), 单条号码_数组_计次)
号码字节集 ＝ 单条号码_字节集数组 [单条号码_数组_计次]
第一个号码 ＝ 取字节集左边 (号码字节集, 1)
分类号 ＝ 哈希表_分类.取值 (第一个号码)
长整数号码 ＝ 到长整数 (到文本 (号码字节集))
模 ＝ 长整数号码 ％ 8 ＋ 1
长整数号码 ＝ 长整数号码 ÷ 8
jici_局哈希 ＝ jici_局哈希 ＋ 1
进入许可区 (许可证)
新结果 ＝ BOr (bitmap [长整数号码], 位与数组 [模])
如果 (新结果 ＝ bitmap [长整数号码])
返回状态 ＝ 2
bitmap [长整数号码] ＝ 新结果
返回状态 ＝ 1

退出许可区 (许可证)
如果 (返回状态 ＝ 2)
jici_局重复 ＝ jici_局重复 ＋ 1



RtlMoveMemory_字节集1 (tempInt_数组 [分类号], { 49 } ＋ 号码字节集 ＋ { 13, 10 }, 13)
tempInt_数组 [分类号] ＝ tempInt_数组 [分类号] ＋ 13

计次循环尾 ()
' ===================
计次循环首 (哈希表_分类.取数量 (), 分类文件_数组_计次)
' WriteFile (文件号_数组 [分类文件_数组_计次], Heap_数组 [分类文件_数组_计次], tempInt_数组 [分类文件_数组_计次] － Heap_数组 [分类文件_数组_计次], 0, 0)
WriteFile (文件号_数组 [1], Heap_数组 [分类文件_数组_计次], tempInt_数组 [分类文件_数组_计次] － Heap_数组 [分类文件_数组_计次], 0, 0)
HeapFree (g_ProcessHeap, 0, Heap_数组 [分类文件_数组_计次])  ' 释放内存
计次循环尾 ()
循环判断尾 (线程执行分块结束 ≠ 处理进度)
关闭文件 (文件号)
进入许可区 (许可证)
jici_哈希 ＝ jici_哈希 ＋ jici_局哈希
jici_重复 ＝ jici_重复 ＋ jici_局重复
线程执行完毕 ＝ 线程执行完毕 ＋ 1
退出许可区 (许可证)

i支持库列表	支持库注释
commobj	通用对象支持库
EThread	多线程支持库

.版本 2<br /> .支持库 commobj<br /> .支持库 EThread<br /> <br /> .子程序 bitmap执行<br /> .参数 分块, 整数型<br /> .局部变量 数据, 快速字节集对象<br /> .局部变量 数据_汇编, 类_快速文本<br /> .局部变量 文件名2, 文本型<br /> .局部变量 文件长度, 整数型<br /> .局部变量 i, 整数型<br /> .局部变量 要替换的字节集, 字节集<br /> .局部变量 替换为, 字节集<br /> .局部变量 处理进度, 整数型<br /> .局部变量 原表项字节集数组, 字节集, , "0"<br /> .局部变量 单条号码, 字节集<br /> .局部变量 单条号码_数组, 文本型, , "0"<br /> .局部变量 单条号码_数组_计次, 整数型<br /> .局部变量 第一个号码, 字节集<br /> .局部变量 文件号, 整数型<br /> .局部变量 Heap, 整数型<br /> .局部变量 内存大小, 整数型<br /> .局部变量 tempInt, 整数型<br /> .局部变量 本线程处理块, 整数型<br /> .局部变量 Heap_数组, 整数型, , "0"<br /> .局部变量 tempInt_数组, 整数型, , "0"<br /> .局部变量 分类文件_数组_计次, 整数型<br /> .局部变量 a, 字节集<br /> .局部变量 zjj, 字节集<br /> .局部变量 单条号码_字节集数组, 字节集, , "0"<br /> .局部变量 号码字节集, 字节集<br /> .局部变量 aa, 整数型<br /> .局部变量 返回状态, 整数型<br /> .局部变量 余数, 整数型<br /> .局部变量 读入大小, 长整数型<br /> .局部变量 总执行, 长整数型<br /> .局部变量 线程执行分块开始, 长整数型<br /> .局部变量 线程执行分块结束, 长整数型<br /> .局部变量 jici_局哈希, 整数型<br /> .局部变量 jici_局重复, 整数型<br /> .局部变量 分类号, 整数型<br /> .局部变量 键, 字节集<br /> .局部变量 值, 整数型<br /> .局部变量 长整数号码, 长整数型<br /> .局部变量 模, 整数型<br /> .局部变量 长整数号码1, 双精度小数型<br /> .局部变量 新结果, 字节型<br /> <br /> 文件号 ＝ 打开文件 (编辑框1.内容, 1, 1)<br /> <br /> 余数 ＝ 文件尺寸 ％ 总分块<br /> <br /> 本线程处理块 ＝ 文件尺寸 ÷ 总分块<br /> <br /> 总执行 ＝ 0<br /> <br /> .如果 (分块 ＝ 总分块)<br />     本线程处理块 ＝ 本线程处理块 － 本线程处理块 ％ 13<br />     线程执行分块开始 ＝ 到长整数 ((分块 － 1) × 本线程处理块)<br />     线程执行分块结束 ＝ 到长整数 (文件尺寸)<br /> <br /> .否则<br />     本线程处理块 ＝ 本线程处理块 － 本线程处理块 ％ 13<br />     线程执行分块开始 ＝ 到长整数 ((分块 － 1) × 本线程处理块)<br />     线程执行分块结束 ＝ 到长整数 (分块 × 本线程处理块)<br /> <br /> .如果结束<br /> 重定义数组 (Heap_数组, 假, 哈希表_分类.取数量 ())<br /> 重定义数组 (tempInt_数组, 假, 哈希表_分类.取数量 ())<br /> <br /> <br /> 读入大小 ＝ 13000<br /> <br /> 内存大小 ＝ 读入大小<br /> <br /> .循环判断首 ()<br /> <br />     .如果 (分块 ≠ 1 且 i ≠ 1)<br />         移动读写位置 (文件号, 1, 线程执行分块开始 － 1)<br />         处理进度 ＝ 取读写位置 (文件号)<br />         i ＝ i ＋ 1<br />     .否则<br /> <br />     .如果结束<br /> <br />     .如果 (处理进度 ＋ 内存大小 ＞ 线程执行分块结束)<br />         读入大小 ＝ 线程执行分块结束 － 处理进度<br />         内存大小 ＝ 读入大小<br />     .否则<br /> <br />     .如果结束<br /> <br /> <br /> <br />     数据.置字节集 (读入字节集 (文件号, 内存大小))<br /> <br />     处理进度 ＝ 取读写位置 (文件号)<br /> <br /> <br /> <br /> <br />     .如果 (处理进度 ＜ 线程执行分块开始 或 处理进度 ＞ 线程执行分块结束)<br />         到循环尾 ()<br />     .否则<br /> <br />     .如果结束<br /> <br /> <br /> <br /> <br /> <br />     .计次循环首 (哈希表_分类.取数量 (), 分类文件_数组_计次)<br />         Heap_数组 [分类文件_数组_计次] ＝ HeapAlloc (g_ProcessHeap, 0, 内存大小)<br />         tempInt_数组 [分类文件_数组_计次] ＝ Heap_数组 [分类文件_数组_计次]<br /> <br />     .计次循环尾 ()<br /> <br />     ' ===================<br /> <br /> <br />     单条号码_字节集数组 ＝ 数据.分割字节集 ({ 13, 10, 49 }, )<br /> <br />     单条号码_字节集数组 [1] ＝ 取字节集右边 (单条号码_字节集数组 [1], 10)<br /> <br />     .如果 (取字节集长度 (取字节集左边 (单条号码_字节集数组 [取数组成员数 (单条号码_字节集数组)], 10)) ＜ 10)<br />         删除成员 (单条号码_字节集数组, 取数组成员数 (单条号码_字节集数组), )<br /> <br />     .否则<br />         单条号码_字节集数组 [取数组成员数 (单条号码_字节集数组)] ＝ 取字节集左边 (单条号码_字节集数组 [取数组成员数 (单条号码_字节集数组)], 10)<br />     .如果结束<br /> <br /> <br /> <br /> <br />     .计次循环首 (取数组成员数 (单条号码_字节集数组), 单条号码_数组_计次)<br />         号码字节集 ＝ 单条号码_字节集数组 [单条号码_数组_计次]<br />         第一个号码 ＝ 取字节集左边 (号码字节集, 1)<br /> <br />         分类号 ＝ 哈希表_分类.取值 (第一个号码)<br /> <br />         长整数号码 ＝ 到长整数 (到文本 (号码字节集))<br /> <br />         模 ＝ 长整数号码 ％ 8 ＋ 1<br />         长整数号码 ＝ 长整数号码 ÷ 8<br /> <br /> <br /> <br />         jici_局哈希 ＝ jici_局哈希 ＋ 1<br />         进入许可区 (许可证)<br />         新结果 ＝ BOr (bitmap [长整数号码], 位与数组 [模])<br /> <br />         .如果 (新结果 ＝ bitmap [长整数号码])<br />             返回状态 ＝ 2<br />         .否则<br />             bitmap [长整数号码] ＝ 新结果<br />             返回状态 ＝ 1<br /> <br />         .如果结束<br /> <br /> <br />         退出许可区 (许可证)<br /> <br />         .如果 (返回状态 ＝ 2)<br />             jici_局重复 ＝ jici_局重复 ＋ 1<br /> <br />         .否则<br /> <br /> <br />             RtlMoveMemory_字节集1 (tempInt_数组 [分类号], { 49 } ＋ 号码字节集 ＋ { 13, 10 }, 13)<br />             tempInt_数组 [分类号] ＝ tempInt_数组 [分类号] ＋ 13<br /> <br />         .如果结束<br /> <br /> <br /> <br />     .计次循环尾 ()<br /> <br /> <br />     ' ===================<br /> <br /> <br /> <br />     .计次循环首 (哈希表_分类.取数量 (), 分类文件_数组_计次)<br /> <br />         ' WriteFile (文件号_数组 [分类文件_数组_计次], Heap_数组 [分类文件_数组_计次], tempInt_数组 [分类文件_数组_计次] － Heap_数组 [分类文件_数组_计次], 0, 0)<br />         WriteFile (文件号_数组 [1], Heap_数组 [分类文件_数组_计次], tempInt_数组 [分类文件_数组_计次] － Heap_数组 [分类文件_数组_计次], 0, 0)<br />         HeapFree (g_ProcessHeap, 0, Heap_数组 [分类文件_数组_计次])  ' 释放内存<br /> <br />     .计次循环尾 ()<br /> .循环判断尾 (线程执行分块结束 ≠ 处理进度)<br /> 关闭文件 (文件号)<br /> <br /> <br /> 进入许可区 (许可证)<br /> jici_哈希 ＝ jici_哈希 ＋ jici_局哈希<br /> jici_重复 ＝ jici_重复 ＋ jici_局重复<br /> 线程执行完毕 ＝ 线程执行完毕 ＋ 1<br /> <br /> 退出许可区 (许可证)

liuhuijun

牛呀 大佬 支持

淡然955t

666666666666

淡然955t

66666666666666666666666666

香蕉山

6666666666666666666666666666666666666666

hdf2015

手机号码去重一千万2秒内，bitmap支持百亿号码，仅耗内存1.2G
厉害了我的楼主

1347379245

感谢分享

我爱樱木

分配内存失败,I5-9400F,16G内存,W10企业版

saina6282

6666666666666666666666666

钱乐

大哥，啥玩意，咋回事！我99G 的文本去重复，开了2小时，还没处理完。我事I9 cpu 。内存48G .