BloomFilter

最新推荐文章于 2023-03-03 11:42:44 发布

u010660276

最新推荐文章于 2023-03-03 11:42:44 发布

阅读量464

点赞数

分类专栏： Hadoop

本文链接：https://blog.csdn.net/u010660276/article/details/50987188

版权

Hadoop 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

BloomFilter是一个大数据处理的算法，它用来判断某个元素是否在集合中。它在空间和时间效率上很高，但是存在移动的误报率。如果返回false，说明元素肯定不在集合中，也就是说不会漏报；但如果返回true，怎可能存在错误。

BloomFilter算法：
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。

这里写图片描述

简单介绍一下代码实现中的几点：
1.java.security.MessageDigest类用于为应用程序提供信息摘要算法的功能，如 MD5 或 SHA 算法。简单点说就是用于生成散列码。信息摘要是安全的单向哈希函数，它接收任意大小的数据，输出固定长度的哈希值。
MessageDigest简介
2.MD5以512位分组来处理输入的信息，且每一分组又被划分为16个32位子分组，经过了一系列的处理后，算法的输出由四个32位分组组成，将这四个32位分组级联后将生成一个128位散列值。

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.BitSet;
import java.util.Random;

import org.apache.commons.math3.analysis.function.Add;
import org.apache.hadoop.io.Writable;

import com.sun.xml.internal.org.jvnet.fastinfoset.VocabularyApplicationData;



public class BloomFilter<E> implements Writable {

    private BitSet bt;
    private int bitArraySize=10000000;
    private int numHashFunc=6;

    public BloomFilter() {
        bt=new BitSet(bitArraySize);
    }
    public void add(E obj){
        int [] index=getHashIndexs(obj);
        for(int x : index){
            bt.set(x);
        }
    }
    public boolean contains(E obj){
        int [] indexs=getHashIndexs(obj);
        for(int x : indexs){
            if(bt.get(x)==false){
                return false;
            }
        }
        return  true;
    }
    public void union(BloomFilter<E> other){
        bt.or(other.bt);
    }
    protected int [] getHashIndexs(E obj) {
        int index []=new int[numHashFunc];
        long seed=0;
        byte [] digest;
        try{
            MessageDigest messageDigest=MessageDigest.getInstance("MD5");
            messageDigest.update(obj.toString().getBytes());
            digest=messageDigest.digest();
            for(int i=0;i<numHashFunc;i++){
                seed=seed^(((long)digest[i]&0xFF))<<(8*i);
            }
        } catch (NoSuchAlgorithmException e){}
        Random random=new Random(seed);
        for(int i=0;i<numHashFunc;i++){
            index[i]=random.nextInt(bitArraySize);
        }
        return index;
    }

    @Override
    public void readFields(DataInput in) throws IOException {
        // TODO Auto-generated method stub

        int byteArraySize=(int)(bitArraySize/8);
        byte [] byteArray=new byte [byteArraySize];
        for(int i=0;i<byteArraySize;i++){
            byte x=0;
            for(int j=0;j<8;j++){
                if((int)(byteArray[i]&(1<<j))!=0){
                    bt.set(8*i+j);
                }
            }
        }
    }

    @Override
    public void write(DataOutput out) throws IOException {
        // TODO Auto-generated method stub
        int byteArraySize=(int)(bitArraySize/8);
        byte [] byteArray=new byte [byteArraySize];
        for(int i=0;i<byteArraySize;i++){
            byte x=0;
            for(int j=0;j<8;j++){
                if(bt.get(8*i+j)){
                    x|=1<<j;
                }
            }
            byteArray[i]=x;
        }
        for(int i=0;i<byteArraySize;i++){
            out.write(byteArray);
        }
    }
}

海量数据处理算法—Bloom Filter
BloomFilter——大规模数据处理利器

生成BloomFilter的MapReduce作业：

import java.io.IOException;
import java.util.Iterator;

import org.apache.commons.lang.ObjectUtils.Null;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapred.FileInputFormat;
import org.apache.hadoop.mapred.FileOutputFormat;
import org.apache.hadoop.mapred.JobClient;
import org.apache.hadoop.mapred.JobConf;
import org.apache.hadoop.mapred.KeyValueTextInputFormat;
import org.apache.hadoop.mapred.MapReduceBase;
import org.apache.hadoop.mapred.Mapper;
import org.apache.hadoop.mapred.OutputCollector;
import org.apache.hadoop.mapred.Reducer;
import org.apache.hadoop.mapred.Reporter;
import org.apache.hadoop.mapred.TextOutputFormat;
import org.apache.hadoop.mapred.lib.NullOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

public class BloomFilterMR extends Configured implements Tool {



    public static class MapClass extends MapReduceBase implements Mapper<Text, Text, Text, BloomFilter<String>>{
        OutputCollector<Text, BloomFilter<String>> outputCollector=null;
        BloomFilter<String> bf=new BloomFilter<String>();
        public void map(Text key,Text value,OutputCollector<Text, BloomFilter<String>> output,Reporter reporter)throws IOException{

            if(outputCollector==null)outputCollector=output;
            bf.add(key.toString());
        }
        public void close()throws IOException{
            outputCollector.collect(new Text("test"), bf);
        }
    }

    public static class Reduce extends MapReduceBase implements Reducer<Text, BloomFilter<String>, Text, Text>{

        BloomFilter<String> bf=new BloomFilter<String>();
        JobConf jobConf=null;
        public void configure(JobConf job){
            jobConf=job;
        }
        public void reduce(Text key,Iterator<BloomFilter<String>> values,OutputCollector<Text , Text > output,Reporter reporter)throws IOException{
            while(values.hasNext()){
                bf.union((BloomFilter<String>)values.next());
            }
        }
        public void close() throws IOException{

            Path file=new Path(jobConf.get("mapred.output.dir")+"/bloomfilter");
            FSDataOutputStream outputStream=file.getFileSystem(jobConf).create(file);
            bf.write(outputStream);
            outputStream.close();
        }
    }

    @Override
    public int run(String[] arg0) throws Exception {
        // TODO Auto-generated method stub

        Configuration configuration=getConf();

        JobConf job=new JobConf(configuration,BloomFilterMR.class);

        FileInputFormat.setInputPaths(job, new Path(arg0[0]));
        FileOutputFormat.setOutputPath(job, new Path(arg0[1]));
        job.setJobName("bloomfilter");
        job.setMapperClass(MapClass.class);
        job.setReducerClass(Reduce.class);
        job.setNumReduceTasks(1);
        job.setInputFormat(KeyValueTextInputFormat.class);
        job.setOutputFormat(NullOutputFormat.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(BloomFilter.class);
        job.set("key.value.separator.in.input.line",",");
        JobClient.runJob(job);
        return 0;
    }

    public static void main(String[] args) throws Exception {
        // TODO Auto-generated method stub

        int res=ToolRunner.run(new Configuration(), new BloomFilterMR(), args);
        System.exit(res);

    }

}