【Bloom Filter】 Bloom Filter(BF)是一种空间效率很高的随机数据结构,它利用位数组很简洁地表示一个集合,并能判断一个元素是否属于这个集合。它是一个判断元素是否存在集合的快速的概率算法。Bloom Filter 有可能会出现错误判断,但不会漏掉判断。也就是 Bloom Filter 判断元素不再集合,那肯定不在。如果判断元素存在集合中,有一定的概率判断错误。因此,Bloom Filter 不适合那些 "零错误" 的应用场合。
而在能容忍低错误率的应用场合下,Bloom Filter 比其他常见的算法(如 hash,折半查找)极大节省了空间。
Bloom Filter 的详细介绍:海量数据处理之 Bloom Filter 详解
【适用范围】 可以用来实现数据字典,进行数据的判重,或者集合求交集
【基本原理及要点】
原理要点:一是位数组, 而是 k 个独立 hash 函数。
1)位数组:
假设 Bloom Filter 使用一个 m 比特的数组来保存信息,初始状态时,Bloom Filter 是一个包含 m 位的位数组,每一位都置为 0,即 BF 整个数组的元素都设置为 0。
2)k 个独立 hash 函数
为了表达 S={x1, x2,…,xn}这样一个 n 个元素的集合,Bloom Filter 使用 k 个相互独立的哈希函数(Hash Function),它们分别将集合中的每个元素映射到 {1,…,m} 的范围中。
当我们往 Bloom Filter 中增加任意一个元素 x 时候,我们使用 k 个哈希函数得到 k 个哈希值,然后将数组中对应的比特位设置为 1。即第 i 个哈希函数映射的位置 hashi(x) 就会被置为 1(1≤i≤k)。 注意,如果一个位置多次被置为 1,那么只有第一次会起作用,后面几次将没有任何效果。在下图中,k=3,且有两个哈希函数选中同一个位置(从左边数第五位,即第二个 "1" 处)。
3)判断元素是否存在集合
在判断 y 是否属于这个集合时,我们只需要对 y 使用 k 个哈希函数得到 k 个哈希值,如果所有 hashi(y) 的位置都是 1(1≤i≤k),即 k 个位置都被设置为 1 了,那么我们就认为 y 是集合中的元素,否则就认为 y 不是集合中的元素。下图中 y1 就不是集合中的元素(因为 y1 有一处指向了 "0" 位)。y2 或者属于这个集合,或者刚好是一个 false positive。
显然这 个判断并不保证查找的结果是 100% 正确的。
Bloom Filter 的缺点:
1)Bloom Filter 无法从 Bloom Filter 集合中删除一个元素。因为该元素对应的位会牵动到其他的元素。所以一个简单的改进就是 counting Bloom filter,用一个 counter 数组代替位数组,就可以支持删除了。 此外,Bloom Filter 的 hash 函数选择会影响算法的效果。
2)还有一个比较重要的问题,如何根据输入元素个数 n,确定位数组 m 的大小及 hash 函数个数,即 hash 函数选择会影响算法的效果。当 hash 函数个数 k=(ln2)*(m/n) 时错误率最小。在错误率不大于 E 的情况 下,m 至少要等于 n*lg(1/E) 才能表示任意 n 个元素的集合。但 m 还应该更大些,因为还要保证 bit 数组里至少一半为 0,则 m 应 该 >=nlg(1/E)*lge ,大概就是 nlg(1/E)1.44 倍 (lg 表示以 2 为底的对数)。
举个例子我们假设错误率为 0.01,则此时 m 应大概是 n 的 13 倍。这样 k 大概是 8 个。
注意:
这里 m 与 n 的单位不同,m 是 bit 为单位,而 n 则是以元素个数为单位 (准确的说是不同元素的个数)。通常单个元素的长度都是有很多 bit 的。所以使用 bloom filter 内存上通常都是节省的。
一般 BF 可以与一些 key-value 的数据库一起使用,来加快查询。由于 BF 所用的空间非常小,所有 BF 可以常驻内存。这样子的话,对于大部分不存在的元素,我们只需要访问内存中的 BF 就可以判断出来了,只有一小部分,我们需要访问在硬盘上的 key-value 数据库。从而大大地提高了效率。
【扩展】 Bloom filter 将集合中的元素映射到位数组中,用 k(k 为哈希函数个数)个映射位是否全 1 表示元素在不在这个集合中。Counting bloom filter(CBF)将位数组中的每一位扩展为一个 counter,从而支持了元素的删除操作。Spectral Bloom Filter(SBF)将其与集合元素的出现次数关联。SBF 采用 counter 中的最小值来近似表示元素的出现频率。
【问题实例】 给你 A,B 两个文件,各存放 50 亿条 URL,每条 URL 占用 64 字节,内存限制是 4G,让你找出 A,B 文件共同的 URL。如果是三个乃至 n 个文件呢? 根据这个问题我们来计算下内存的占用,4G=2^32 大概是 40 亿 * 8 大概是 340 亿 bit,n=50 亿,如果按出错率 0.01 算需要的大概是 650 亿个 bit。 现在可用的是 340 亿,相差并不多,这样可能会使出错率上升些。另外如果这些 urlip 是一一对应的,就可以转换成 ip,则大大简单了。
【什么是 Hash】 Hash,一般翻译做 "散列",也有直接音译为 "哈希" 的,就是把任意长度的输入(又叫做预映射, pre-image),通过散列算法,变换成固定长度的输出,该输出就是散列值。这种转换是一种压缩映射,也就是,散列值的空间通常远小于输入的空间,不同的输入可能会散列成相同的输出,而不可能从散列值来唯一的确定输入值。简单的说就是一种将任意长度的消息压缩到某一固定长度的消息摘要的函数。 HASH 主要用于信息安全领域中加密算法,它把一些不同长度的信息转化成杂乱的 128 位的编码, 这些编码值叫做 HASH 值. 也可以说,hash 就是找到一种数据内容和数据存放地址之间的映射关系。 数组的特点是:寻址容易,插入和删除困难;而链表的特点是:寻址困难,插入和删除容易。那么我们能不能综合两者的特性,做出一种寻址容易,插入删除也容易的数据结构?答案是肯定的,这就是我们要提起的哈希表,哈希表有多种不同的实现方法,我接下来解释的是最常用的一种方法——拉链法,(也是树的一种存储结构,称为二叉链表)我们可以理解为 "链表的数组",如图:
左边很明显是个数组,数组的每个成员包括一个指针,指向一个链表的头,当然这个链表可能为空,也可能元素很多。我们根据元素的一些特征把元素分配到不同的链表中去,也是根据这些特征,找到正确的链表,再从链表中找出这个元素。 元素特征转变为数组下标的方法就是散列法。
散列法当然不止一种,下面列出三种比较常用的: 1,除法散列法 (求模数) 最直观的一种,上图使用的就是这种散列法,公式: index = value % 16 学过汇编的都知道,求模数其实是通过一个除法运算得到的,所以叫 "除法散列法"。 2,平方散列法 求 index 是非常频繁的操作,而乘法的运算要比除法来得省时(对现在的 CPU 来说,估计我们感觉不出来),所以我们考虑把除法换成乘法和一个位移操作。公式: index = (value * value) >> 28 如果数值分配比较均匀的话这种方法能得到不错的结果,但我上面画的那个图的各个元素的值算出来的 index 都是 0——非常失败。也许你还有个问题,value 如果很大,value * value 不会溢出吗?答案是会的,但我们这个乘法不关心溢出,因为我们根本不是为了获取相乘结果,而是为了获取 index。 3,斐波那契(Fibonacci)散列法 平方散列法的缺点是显而易见的,所以我们能不能找出一个理想的乘数,而不是拿 value 本身当作乘数呢?答案是肯定的。 1,对于 16 位整数而言,这个乘数是 40503 2,对于 32 位整数而言,这个乘数是 2654435769 3,对于 64 位整数而言,这个乘数是 11400714819323198485 这几个 "理想乘数" 是如何得出来的呢?这跟一个法则有关,叫黄金分割法则,而描述黄金分割法则的最经典表达式无疑就是著名的斐波那契数列,如果你还有兴趣,就到网上查找一下 "斐波那契数列" 等关键字,我数学水平有限,不知道怎么描述清楚为什么,另外斐波那契数列的值居然和太阳系八大行星的轨道半径的比例出奇吻合,很神奇,对么? 对我们常见的 32 位整数而言,公式: i ndex = (value * 2654435769) >> 28 如果用这种斐波那契散列法的话,那我上面的图就变成这样了:
很明显,用斐波那契散列法调整之后要比原来的取摸散列法好很多。 【适用范围】 快速查找,删除的基本数据结构,通常需要总数据量可以放入内存。 【基本原理及要点】 hash 函数选择,针对字符串,整数,排列,具体相应的 hash 方法。 碰撞处理:
一种是 open hashing,也称为拉链法;
另一种就是 closed hashing,也称开地址法,opened addressing。 【扩展】 d-left hashing 中的 d 是多个的意思,我们先简化这个问题,看一看 2-left hashing。2-left hashing 指的是将一个哈希表分成长度相等的两半,分别叫做 T1 和 T2,给 T1 和 T2 分别配备一个哈希函数,h1 和 h2。在存储一个新的 key 时,同 时用两个哈希函数进行计算,得出两个地址 h1[key] 和 h2[key]。这时需要检查 T1 中的 h1[key] 位置和 T2 中的 h2[key] 位置,哪一个 位置已经存储的(有碰撞的)key 比较多,然后将新 key 存储在负载少的位置。如果两边一样多,比如两个位置都为空或者都存储了一个 key,就把新 key 存储在左边的 T1 子表中,2-left 也由此而来。在查找一个 key 时,必须进行两次 hash,同时查找两个位置。 【问题实例】 1). 海量日志数据,提取出某日访问百度次数最多的那个 IP。 IP 的数目还是有限的,最多 2^32 个,所以可以考虑使用 hash 将 ip 直接存入内存,然后进行统计。
【什么是 Bit-map】 所谓的 Bit-map 就是用一个 bit 位来标记某个元素对应的 Value, 而 Key 即是该元素。由于采用了 Bit 为单位来存储数据,因此在存储空间方面,可以大大节省。
如果说了这么多还没明白什么是 Bit-map,那么我们来看一个具体的例子,假设我们要对 0-7 内的 5 个元素 (4,7,2,5,3) 排序(这里假设这些元素没有重复)。那么我们就可以采用 Bit-map 的方法来达到排序的目的。要表示 8 个数,我们就只需要 8 个 Bit(1Bytes),首先我们开辟 1Byte 的空间,将这些空间的所有 Bit 位都置为 0(如下图:)
然后遍历这 5 个元素,首先第一个元素是 4,那么就把 4 对应的位置为 1(可以这样操作 p+(i/8)|(0x01<<(i%8)) 当然了这里的操作涉及到 Big-ending 和 Little-ending 的情况,这里默认为 Big-ending), 因为是从零开始的,所以要把第五位置为一(如下图):
然后再处理第二个元素 7,将第八位置为 1,,接着再处理第三个元素,一直到最后处理完所有的元素,将相应的位置为 1,这时候的内存的 Bit 位的状态如下:
然后我们现在遍历一遍 Bit 区域,将该位是一的位的编号输出(2,3,4,5,7),这样就达到了排序的目的。下面的代码给出了一个 BitMap 的用法:排序。
C 代码
- 1 //定义每个Byte中有8个Bit位
- 2#include<memory.h>3#define BYTESIZE 8 4 void SetBit(char * p, int posi) 5 {
- 6
- for (int i = 0; i< (posi / BYTESIZE); i++) 7 {
- 8 p++;
- 9
- }
- 10 11 * p = *p | (0x01<< (posi % BYTESIZE)); //将该Bit位赋值1
- 12
- return;
- 13
- }
- 14 15 void BitMapSortDemo() 16 {
- 17 //为了简单起见,我们不考虑负数
- 18 int num[] = {
- 3,
- 5,
- 2,
- 10,
- 6,
- 12,
- 8,
- 14,
- 9
- };
- 19 20 //BufferLen这个值是根据待排序的数据中最大值确定的
- 21 //待排序中的最大值是14,因此只需要2个Bytes(16个Bit)
- 22 //就可以了。
- 23 const int BufferLen = 2;
- 24 char * pBuffer = new char[BufferLen];
- 25 26 //要将所有的Bit位置为0,否则结果不可预知。
- 27 memset(pBuffer, 0, BufferLen);
- 28
- for (int i = 0; i<9; i++) 29 {
- 30 //首先将相应Bit位上置为1
- 31 SetBit(pBuffer, num[i]);
- 32
- }
- 33 34 //输出排序结果
- 35
- for (int i = 0; i<BufferLen; i++) //每次处理一个字节(Byte)
- 36 {
- 37
- for (int j = 0; j<BYTESIZE; j++) //处理该字节中的每个Bit位
- 38 {
- 39 //判断该位上是否是1,进行输出,这里的判断比较笨。
- 40 //首先得到该第j位的掩码(0x01<<j),将内存区中的
- 41 //位和此掩码作与操作。最后判断掩码是否和处理后的
- 42 //结果相同
- 43
- if (( * pBuffer & (0x01<<j)) == (0x01<<j)) 44 {
- 45 printf("%d ", i * BYTESIZE + j);
- 46
- }
- 47
- }
- 48 pBuffer++;
- 49
- }
- 50
- }
- 51 52 int _tmain(int argc, _TCHAR * argv[]) 53 {
- 54 BitMapSortDemo();
- 55
- return 0;
- 56
- }
【适用范围】 可进行数据的快速查找,判重,删除,一般来说数据范围是 int 的 10 倍以下
【基本原理及要点】 使用 bit 数组来表示某些元素是否存在,比如 8 位电话号码 【扩展】 Bloom filter 可以看做是对 bit-map 的扩展 【问题实例】 1) 已知某个文件内包含一些电话号码,每个号码为 8 位数字,统计不同号码的个数。 8 位最多 99 999 999,大概需要 99m 个 bit(1024*1024 *99 个 bit ),大概 10 几 m 字节的内存即可。
申请内存空间的大小为: int a[1 + N/32] =((99 999 999/32 +1)*4 个字节 / 1024/1024 = 12M
(可以理解为从 0-99 999 999 的数字,每个数字对应一个 Bit 位,所以只需要 99M 个 Bit==12MBytes,这样,就用了小小的 12M 左右的内存表示了所有的 8 位数的电话) 2)2.5 亿个整数中找出不重复的整数的个数,内存空间不足以容纳这 2.5 亿个整数。 将 bit-map 扩展一下,用 2bit 表示一个数即可,0 表示未出现,1 表示出现一次,2 表示出现 2 次及以上,在遍历这些数的时候,如果对应位置的值是 0,则将其置为 1;如果是 1,将其置为 2;如果是 2,则保持不变。或者我们不用 2bit 来进行表示,我们用两个 bit-map 即可模拟实现这个 2bit-map,都是一样的道理。
【什么是堆】
在八大排序里面有堆 的详细介绍:八大排序算法 概念:堆是一种特殊的二叉树,具备以下两种性质 1)每个节点的值都大于(或者都小于,称为最小堆)其子节点的值 2)树是完全平衡的,并且最后一层的树叶都在最左边 这样就定义了一个最大堆。如下图用一个数组来表示堆:
那么下面介绍二叉堆:二叉堆是一种完全二叉树,其任意子树的左右节点(如果有的话)的键值一定比根节点大,上图其实就是一个二叉堆。
你一定发觉了,最小的一个元素就是数组第一个元素,那么二叉堆这种有序队列如何入队呢?看图:
假设要在这个二叉堆里入队一个单元,键值为 2,那只需在数组末尾加入这个元素,然后尽可能把这个元素往上挪,直到挪不动,经过了这种复杂度为Ο(logn) 的操作,二叉堆还是二叉堆。
那如何出队呢?也不难,看图
出队一定是出数组的第一个元素,这么来第一个元素以前的位置就成了空位,我们需要把这个空位挪至叶子节点,然后把数组最后一个元素插入这个空位,把这个 "空位" 尽量往上挪。这种操作的复杂度也是Ο(logn)。
【适用范围】 海量数据前 n 大,并且 n 比较小,堆可以放入内存
【基本原理及要点】 最大堆求前 n 小,最小堆求前 n 大。方法,比如求前 n 小,我们比较当前元素与最大堆里的最大元素,如果它小于最大元素,则应该替换那个最大元 素。这样最后得到的 n 个元素就是最小的 n 个。适合大数据量,求前 n 小,n 的大小比较小的情况,这样可以扫描一遍即可得到所有的前 n 元素,效率很高。
【扩展】 双堆,一个最大堆与一个最小堆结合,可以用来维护中位数。
【问题实例】 1)100w 个数中找最大的前 100 个数。 用一个 100 个元素大小的最小堆即可。
【什么是双层桶】 事实上,与其说双层桶划分是一种数据结构,不如说它是一种算法设计思想。面对一堆大量的数据我们无法处理的时候,我们可以将其分成一个个小的单元,然后根据一定的策略来处理这些小单元,从而达到目的。
【适用范围】 第 k 大,中位数,不重复或重复的数字
【基本原理及要点】 因为元素范围很大,不能利用直接寻址表,所以通过多次划分,逐步确定范围,然后最后在一个可以接受的范围内进行。可以通过多次缩小,双层只是一个例子,分治才是其根本(只是 "只分不治")。
【扩展】 当有时候需要用一个小范围的数据来构造一个大数据,也是可以利用这种思想,相比之下不同的,只是其中的逆过程。
【问题实例】 1).2.5 亿个整数中找出不重复的整数的个数,内存空间不足以容纳这 2.5 亿个整数。
有 点像鸽巢原理,整数个数为 2^32, 也就是,我们可以将这 2^32 个数,划分为 2^8=256 个区域 (比如用单个文件代表一个区域),然后将数据分离到不同的区 域,然后不同的区域在利用 bitmap 就可以直接解决了。也就是说只要有足够的磁盘空间,就可以很方便的解决。 当然这个题也可以用我们前面讲过的 BitMap 方法解决,正所谓条条大道通罗马~~~
2).5 亿个 int 找它们的中位数。
这个例子比上面那个更明显。首先我们将 int 划分为 2^16 个区域,然后读取数据统计落到各个区域里的数的个数,之后我们根据统计结果就可以判断中位数落到那个区域,同时知道这个区域中的第几大数刚好是中位数。然后第二次扫描我们只统计落在这个区域中的那些数就可以了。
实 际上,如果不是 int 是 int64,我们可以经过 3 次这样的划分即可降低到可以接受的程度。即可以先将 int64 分成 2^24 个区域,然后确定区域的第几 大数,在将该区域分成 2^20 个子区域,然后确定是子区域的第几大数,然后子区域里的数的个数只有 2^20,就可以直接利用 direct addr table 进行统计了。
3). 现在有一个 0-30000 的随机数生成器。请根据这个随机数生成器,设计一个抽奖范围是 0-350000 彩票中奖号码列表,其中要包含 20000 个中奖号码。
这个题刚好和上面两个思想相反,一个 0 到 3 万的随机数生成器要生成一个 0 到 35 万的随机数。那么我们完全可以将 0-35 万的区间分成 35/3=12 个区 间,然后每个区间的长度都小于等于 3 万,这样我们就可以用题目给的随机数生成器来生成了,然后再加上该区间的基数。那么要每个区间生成多少个随机数呢?计 算公式就是:区间长度 * 随机数密度,在本题目中就是 30000*(20000/350000)。最后要注意一点,该题目是有隐含条件的:彩票,这意味着你 生成的随机数里面不能有重复,这也是我为什么用双层桶划分思想的另外一个原因。
索引是对数据库表中一列或多列的值进行排序的一种结构,使用索引可快速访问数据库表中的特定信息。
数据库索引好比是一本书前面的目录,能加快数据库的查询速度。 例如这样一个查询:select * from table1 where id=44。如果没有索引,必须遍历整个表,直到 ID 等于 44 的这一行被找到为止;有了索引之后 (必须是在 ID 这一列上建立的索引),直接在索引里面找 44(也就是在 ID 这一列找),就可以得知这一行的位置,也就是找到了这一行。可见,索引是用来定位的。 索引分为聚簇索引和非聚簇索引两种,聚簇索引 是按照数据存放的物理位置为顺序的,而非聚簇索引就不一样了;聚簇索引能提高多行检索的速度,而非聚簇索引对于单行的检索很快。
建立索引的目的是加快对表中记录的查找或排序。 为表设置索引要付出代价的:一是增加了数据库的存储空间,二是在插入和修改数据时要花费较多的时间 (因为索引也要随之变动)。
创建索引可以大大提高系统的性能。 第一,通过创建唯一性索引,可以保证数据库表中每一行数据的唯一性。 第二,可以大大加快数据的检索速度,这也是创建索引的最主要的原因。 第三,可以加速表和表之间的连接,特别是在实现数据的参考完整性方面特别有意义。 第四,在使用分组和排序子句进行数据检索时,同样可以显著减少查询中分组和排序的时间。 第五,通过使用索引,可以在查询的过程中,使用优化隐藏器,提高系统的性能。 也许会有人要问:增加索引有如此多的优点,为什么不对表中的每一个列创建一个索引呢?因为,增加索引也有许多不利的方面。 第一,创建索引和维护索引要耗费时间,这种时间随着数据量的增加而增加。 第二,索引需要占物理空间,除了数据表占数据空间之外,每一个索引还要占一定的物理空间,如果要建立聚簇索引,那么需要的空间就会更大。 第三,当对表中的数据进行增加、删除和修改的时候,索引也要动态的维护,这样就降低了数据的维护速度。
索引是建立在数据库表中的某些列的上面。在创建索引的时候,应该考虑在哪些列上可以创建索引,在哪些列上不能创建索引。一般来说,应该在这些列上创建索引: 在经常需要搜索的列上,可以加快搜索的速度; 在作为主键的列上,强制该列的唯一性和组织表中数据的排列结构; 在经常用在连接的列上,这些列主要是一些外键,可以加快连接的速度;在经常需要根据范围进行搜索的列上创建索引,因为索引已经排序,其指定的范围是连续的; 在经常需要排序的列上创建索引,因为索引已经排序,这样查询可以利用索引的排序,加快排序查询时间; 在经常使用在 WHERE 子句中的列上面创建索引,加快条件的判断速度。 同样,对于有些列不应该创建索引。一般来说,不应该创建索引的的这些列具有下列特点: 第一,对于那些在查询中很少使用或者参考的列不应该创建索引。这是因为,既然这些列很少使用到,因此有索引或者无索引,并不能提高查询速度。相反,由于增加了索引,反而降低了系统的维护速度和增大了空间需求。 第二,对于那些只有很少数据值的列也不应该增加索引。这是因为,由于这些列的取值很少,例如人事表的性别列,在查询的结果中,结果集的数据行占了表中数据行的很大比例,即需要在表中搜索的数据行的比例很大。增加索引,并不能明显加快检索速度。 第三,对于那些定义为 text, image 和 bit 数据类型的列不应该增加索引。这是因为,这些列的数据量要么相当大,要么取值很少, 不利于使用索引。 第四,当修改性能远远大于检索性能时,不应该创建索引。这是因为,修改性能和检索性能是互相矛盾的。当增加索引时,会提高检索性能,但是会降低修改性能。当减少索引时,会提高修改性能,降低检索性能。因此,当修改操作远远多于检索操作时,不应该创建索引。
此外,除了数据库索引之外,在 LAMP 结果如此流行的今天,数据库(尤其是 MySQL)性能优化也是海量数据处理的一个热点。下面就结合自己的经验,聊一聊 MySQL 数据库优化的几个方面。 首先,在数据库设计的时候,要能够充分的利用索引带来的性能提升,至于如何建立索引,建立什么样的索引,在哪些字段上建立索引,上面已经讲的很清楚了,这里不在赘述。另外就是设计数据库的原则就是尽可能少的进行数据库写操作(插入,更新,删除等),查询越简单越好。如下:
数据库设计:
. 创建索引
. 查询语句
1)查询越简单越好: 单表查询 > inner join > 其他
2)更新越少越好
其次,配置缓存是必不可少的,配置缓存可以有效的降低数据库查询读取次数,从而缓解数据库服务器压力,达到优化的目的,一定程度上来讲,这算是一个 "围魏救赵" 的办法。可配置的缓存包括索引缓存 (key_buffer),排序缓存 (sort_buffer),查询缓存 (query_buffer),表描述符缓存 (table_cache),如下:
配置缓存:
. 索引缓存(key_buffer)
. 排序缓存 (sort_buffer)
. 查询缓存 (query_buffer)
. 表描述符缓存(table_cache)
第三,切表,切表也是一种比较流行的数据库优化法。分表包括两种方式:横向分表和纵向分表,其中,横向分表比较有使用意义,故名思议,横向切表就是指把记录分到不同的表中,而每条记录仍旧是完整的(纵向切表后每条记录是不完整的),例如原始表中有 100 条记录,我要切成 2 个表,那么最简单也是最常用的方法就是 ID 取摸切表法,本例中,就把 ID 为 1,3,5,7。。。的记录存在一个表中,ID 为 2,4,6,8,。。。的记录存在另一张表中。虽然横向切表可以减少查询强度,但是它也破坏了原始表的完整性,如果该表的统计操作比较多,那么就不适合横向切表。横向切表有个非常典型的用法,就是用户数据:每个用户的用户数据一般都比较庞大,但是每个用户数据之间的关系不大,因此这里很适合横向切表。最后,要记住一句话就是:分表会造成查询的负担,因此在数据库设计之初,要想好是否真的适合切表的优化:
切表分表:
. 纵向 :字段较多时可以考虑,一般用处不到
. 横向 :1)能有效降低表的大小,减少由于枷锁导致的等待
2)查询会变得复杂,尤其是需要排序的查询
第四,日志分析,在数据库运行了较长一段时间以后,会积累大量的 LOG 日志,其实这里面的蕴涵的有用的信息量还是很大的。通过分析日志,可以找到系统性能的瓶颈,从而进一步寻找优化方案。
数据库性能分析:
. 查询吞吐量,数据量监控
. 慢查询分析:索引,I/O,cpu 等。
以上讲的都是单机 MySQL 的性能优化的一些经验,但是随着信息大爆炸,单机的数据库服务器已经不能满足我们的需求,于是,多多节点,分布式数据库网络出现了,其一般的结构如下:
分布式数据库结构
这种分布式集群的技术关键就是 "同步复制"。。。
引言:
在信息大爆炸的今天,有了搜索引擎的帮助,使得我们能够快速,便捷的找到所求。提到搜索引擎,就不得不说 VSM 模型,说到 VSM,就不得不聊倒排索引。可以毫不夸张的讲,倒排索引是搜索引擎的基石。
VSM 检索模型
VSM 全称是 Vector Space Model(向量空间模型),是 IR(Information Retrieval 信息检索) 模型中的一种,由于其简单,直观,高效,所以被广泛的应用到搜索引擎的架构中。98 年的 Google 就是凭借这样的一个模型,开始了它的疯狂扩张之路。废话不多说,让我们来看看到底 VSM 是一个什么东东。
在开始之前,我默认大家对线性代数里面的向量 (Vector) 有一定了解的。向量是既有大小又有方向的量,通常用有向线段表示,向量有:加、减、倍数、内积、距离、模、夹角的运算。
文档 (Document):一个完整的信息单元,对应的搜索引擎系统里,就是指一个个的网页。
标引项 (Term):文档的基本构成单位,例如在英文中可以看做是一个单词,在中文中可以看作一个词语。
查询 (Query):一个用户的输入,一般由多个 Term 构成。
那么用一句话概况搜索引擎所做的事情就是:对于用户输入的 Query,找到最相似的 Document 返回给用户。而这正是 IR 模型所解决的问题:
信息检索模型是指如何对查询和文档进行表示,然后对它们进行相似度计算的框架和方法。
举个简单的例子:
现在有两篇文章 (Document) 分别是 "春风来了,春天的脚步近了" 和 "春风不度玉门关"。然后输入的 Query 是 "春风",从直观上感觉,前者和输入的查询更相关一些,因为它包含有 2 个春,但这只是我们的直观感觉,如何量化呢,要知道计算机是门严谨的学科 ^_^。这个时候,我们前面讲的 Term 和 VSM 模型就派上用场了。
首先我们要确定向量的维数,这时候就需要一个字典库,字典库的大小,即是向量的维数。在该例中,字典为 {春风, 来了, 春天, 的, 脚步, 近了, 不度, 玉门关} ,文档向量,查询向量如下图:
PS: 为了简单起见,这里分词的粒度很大。
将 Query 和 Document 都量化为向量以后,那么就可以计算用户的查询和哪个文档相似性更大了。简单的计算结果是 D1 和 D2 同 Query 的内积都是 1,囧。当然了,如果分词粒度再细一些,查询的结果就是另外一个样子了,因此分词的粒度也是会对查询结果(主要是召回率和准确率)造成影响的。
上述的例子是用一个很简单的例子来说明 VSM 模型的,计算文档相似度的时候也是采用最原始的内积的方法,并且只考虑了词频 (TF) 影响因子,而没有考虑反词频(IDF),而现在比较常用的是 cos 夹角法,影响因子也非常多,据传 Google 的影响因子有 100 + 之多。 大名鼎鼎的 Lucene 项目就是采用 VSM 模型构建的,VSM 的核心公式如下(由 cos 夹角法演变,此处省去推导过程)
从上面的例子不难看出,如果向量的维度 (对汉语来将,这个值一般在 30w-45w) 变大,而且文档数量 (通常都是海量的) 变多,那么计算一次相关性,开销是非常大的,如何解决这个问题呢?不要忘记了我们这节的主题就是 倒排索引,主角终于粉墨登场了!!!
倒排索引非常类似我们前面提到的 Hash 结构。以下内容来自维基百科:
倒排索引(英语:Inverted index),也常被称为反向索引、置入档案或反向档案,是一种索引方法,被用来存储在全文搜索下某个单词在一个文档或者一组文档中的存储位置的映射。它是文档检索系统中最常用的数据结构。
有两种不同的反向索引形式:
后者的形式提供了更多的兼容性(比如短语搜索),但是需要更多的时间和空间来创建。
由上面的定义可以知道,一个倒排索引包含一个字典的索引和所有词的列表。其中字典索引中包含了所有的 Term(通俗理解为文档中的词),索引后面跟的列表则保存该词的信息 (出现的文档号,甚至包含在每个文档中的位置信息)。下面我们还采用上面的方法举一个简单的例子来说明倒排索引。
例如现在我们要对三篇文档建立索引 (实际应用中,文档的数量是海量的):
文档 1(D1):中国移动互联网发展迅速
文档 2(D2):移动互联网未来的潜力巨大
文档 3(D3):中华民族是个勤劳的民族
那么文档中的词典集合为:{中国,移动,互联网,发展,迅速,未来,的,潜力,巨大,中华,民族,是,个,勤劳}
建好的索引如下图:
在上面的索引中,存储了两个信息,文档号和出现的次数。建立好索引以后,我们就可以开始查询了。例如现在有一个 Query 是 "中国移动"。首先分词得到 Term 集合 {中国,移动},查倒排索引,分别计算 query 和 d1,d2,d3 的距离。有没有发现,倒排表建立好以后,就不需要在检索整个文档库,而是直接从字典集合中找到 "中国" 和 "移动",然后遍历后面的列表直接计算。
对倒排索引结构我们已经有了初步的了解,但在实际应用中还有些需要解决的问题 (主要是由海量数据引起的)。笔者列举一些问题,并给出相应的解决方案,抛砖以引玉,希望大家可以展开讨论:
1. 左侧的索引表如何建立? 怎么做才能最高效?
可能有人不假思索回答:左侧的索引当然要采取 hash 结构啊,这样可以快速的定位到字典项。但是这样问题又来了,hash 函数如何选取呢?而且 hash 是有碰撞的,但是倒排表似乎又是不允许碰撞的存在的。事实上,虽然倒排表和 hash 异常的相思,但是两者还是有很大区别的,其实在这里我们可以采用前面提到的 Bitmap 的思想,每个 Term(单词)对应一个位置 (当然了,这里不是一个比特位),而且是一一对应的。如何能够做到呢,一般在文字处理中,有很多的编码,汉字中的 GBK 编码基本上就可以包含所有用到的汉字,每个汉字的 GBK 编码是确定的,因此一个 Term 的 "ID" 也就确定了,从而可以做到快速定位。注:得到一个汉字的 GBK 号是非常快的过程,可以理解为 O(1) 的时间复杂度。
2. 如何快速的添加删除更新索引?
有经验的码农都知道,一般在系统的 "做加法" 的代价比 "做减法" 的代价要低很多,在搜索引擎中中也不例外。因此,在倒排表中,遇到要删除一个文档,其实不是真正的删除,而是将其标记删除。这样一个减法操作的代价就比较小了。
3. 那么多的海量文档,如果存储呢?有么有什么备份策略呢?
当然了,一台机器是存储不下的,分布式存储是采取的。一般的备份保存 3 份就足够了。
好了,倒排索引终于完工了,不足的地方请指正。谢谢
适用范围:
大数据的排序,去重 基本原理及要点:
外部排序的两个独立阶段:
1)首先按内存大小,将外存上含 n 个记录的文件分成若干长度 L 的子文件或段。依次读入内存并利用有效的内部排序对他们进行排序,并将排序后得到的有序字文件重新写入外存,通常称这些子文件为归并段。
2)对这些归并段进行逐趟归并,使归并段逐渐由小到大,直至得到整个有序文件为之。
外排序的归并方法,置换选择 败者树原理,最优归并树 扩展: 问题实例: 1). 有一个 1G 大小的一个文件,里面每一行是一个词,词的大小不超过 16 个字节,内存限制大小是 1M。返回频数最高的 100 个词这个数据具有很明显的特点,词的大小为 16 个字节,但是内存只有 1m 做 hash 有些不够,所以可以用来排序。内存可以当输入缓冲区使用。
适用范围:
数据量大,重复多,但是数据种类小可以放入内存
基本原理及要点:
实现方式,节点孩子的表示方式 扩展:
压缩实现。 问题实例: 1). 有 10 个文件,每个文件 1G, 每个文件的每一行都存放的是用户的 query,每个文件的 query 都可能重复。要你按照 query 的频度排序 。 2).1000 万字符串,其中有些是相同的 (重复), 需要把重复的全部去掉,保留没有重复的字符串。请问怎么设计和实现? 3). 寻找热门查询:查询串的重复度比较高,虽然总数是 1 千万,但如果除去重复后,不超过 3 百万个,每个不超过 255 字节。
基本原理及要点:
将数据交给不同的机器去处理,数据划分,结果归约。
扩 展: 问题实例: 1).The canonical example application of MapReduce is a process to count the appearances of each different word in a set of documents: void map(String name, String document): // name: document name // document: document contents for each word w in document: EmitIntermediate(w, 1); void reduce(String word, Iterator partialCounts): // key: a word // values: a list of aggregated partial counts int result = 0; for each v in partialCounts: result += ParseInt(v); Emit(result); Here, each document is split in words, and each word is counted initially with a "1" value by the Map function, using the word as the result key. The framework puts together all the pairs with the same key and feeds them to the same call to Reduce, thus this function just needs to sum all of its input values to find the total appearances of that word. 2). 海量数据分布在 100 台电脑中,想个办法高效统计出这批数据的 TOP10。 3). 一共有 N 个机器,每个机器上有 N 个数。每个机器最多存 O(N)个数并对它们操作。如何找到 N^2 个数的中数 (median)? 经典问题分析 上千万 or 亿数据(有 重复),统计其中出现次数最多的前 N 个数据, 分两种情况:可一次读入内存,不可一次读入。 可用思路:trie 树 + 堆,数据库索引,划分 子集分别统计,hash,分布式计算,近似统计,外排序 所谓的是否能一次读入内存,实际上应该指去除重复后的数据量。如果去重后数据可 以放入内存,我们可以为数据建立字典,比如通过 map,hashmap,trie,然后直接进行统计即可。当然在更新每条数据的出现次数的时候,我们可以利用一个堆来维护出现次数最多的前 N 个数据,当然这样导致维护次数增加,不如完全统计后在求前 N 大效率高。 如果数据无法放入内存。一方面我们可以考虑上面的字典方法能否被改进以适应这种情形,可以做的改变就是将字典存放到硬盘上,而不是内存,这可以参考数据库的存储方法。 当然还有更好的方法,就是可以采用分布式计算,基本上就是 map-reduce 过程,首先可以根据数据值或者把数据 hash(md5) 后的值,将数据按照范围划分到不同的机子,最好可以让数据划分后可以一次读入内存,这样不同的机子负责处理各种的数值范围,实际上就是 map。得到结果后,各个机子只需拿出各自的出现次数最多的前 N 个数据,然后汇总,选出所有的数据中出现次数最多的前 N 个数据,这实际上就是 reduce 过程。 实际上可能想直接将数据均分到不同的机子上进行处理,这样是无法得到正确的解的。因为一个数据可能被均分到不同的机子上,而另一个则可能完全聚集到一个机子上,同时还可能存在具有相同数目的数据。比如我们要找出现次数最多的前 100 个,我们将 1000 万的数据分布到 10 台机器上,找到每台出现次数最多的前 100 个,归并之后这样不能保证找到真正的第 100 个,因为比如出现次数最多的第 100 个可能有 1 万个,但是它被分到了 10 台机子,这样在每台上只有 1 千个,假设这些机子排名在 1000 个之前的那些都是单独分布在一台机子上的,比如有 1001 个,这样本来具有 1 万个的这个就会被淘汰,即使我们让每台机子选出出现次数最多的 1000 个再归并,仍然会出错,因为可能存在大量个数为 1001 个的发生聚集。因此不能将数据随便均分到不同机子上,而是要根据 hash 后的值将它们映射到不同的机子上处理,让不同的机器处理一个数值范围。 而外排序的方法会消耗大量的 IO,效率不会很高
来源: http://www.cnblogs.com/ECJTUACM-873284962/p/6910842.html