04-常见mr算法实现和shuffle的机制

最新推荐文章于 2025-08-07 15:19:17 发布
原创 最新推荐文章于 2025-08-07 15:19:17 发布 · 1.9k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#hadoop

本文介绍Hadoop中自定义序列化接口Writable及排序接口Comparable的应用，并演示如何实现自定义类型的序列化、排序、分区及使用Combiner。

hadoop中的序列化机制

Writable,接口是序列化的接口，Comparable是排序实现接口

 1.自定义传递值的类型 
  1. package com.apollo.mr.flowsum;
  2. 

  3. import org.apache.hadoop.io.WritableComparable;
  4. 

  5. import java.io.DataInput;
  6. import java.io.DataOutput;
  7. import java.io.IOException;
  8. 

  9. /**
  10.  * Writable是序列化接口，Comparable是排序接口，MR中排序是按照key来排序的
  11.  * Created by 85213 on 2016/12/13.
  12.  */
  13. public class FlowBean implements WritableComparable<FlowBean> {
  14.     private String phoneNB;
  15.     private long u_flow;
  16.     private long d_flow;
  17.     private long s_flow;
  18. 

  19.     //在反序列化时，反射机制需要调用空参构造函数，所以显示定义了一个空参构造函数
  20.     public FlowBean(){}
  21. 

  22.     //为了对象数据的初始化方便，加入一个带参的构造函数
  23.     public FlowBean(String phoneNB,long u_flow,long d_flow){
  24.         this.phoneNB = phoneNB;
  25.         this.u_flow = u_flow;
  26.         this.d_flow = d_flow;
  27.         this.s_flow = u_flow+d_flow;
  28.     }
  29. 

  30.     //将对象数据序列化到流中
  31.     @Override
  32.     public void write(DataOutput out) throws IOException {
  33.         out.writeUTF(phoneNB);
  34.         out.writeLong(u_flow);
  35.         out.writeLong(d_flow);
  36.         out.writeLong(s_flow);
  37.     }
  38. 

  39.     //注意顺序要和序列化的顺序一致
  40.     @Override
  41.     public void readFields(DataInput in) throws IOException {
  42.         phoneNB = in.readUTF();
  43.         u_flow = in.readLong();
  44.         d_flow = in.readLong();
  45.         s_flow = in.readLong();
  46.     }
  47. 

  48.     //排序规则，这里实现倒序排序
  49.     @Override
  50.     public int compareTo(FlowBean o) {
  51.         return s_flow > o.s_flow ?-1:1;
  52.     }
  53. 

  54.     public String toString() {
  55.         return "" + u_flow + "\t" +d_flow + "\t" + s_flow;
  56.     }
  57. 

  58.     public String getPhoneNB() {
  59.         return phoneNB;
  60.     }
  61. 

  62.     public void setPhoneNB(String phoneNB) {
  63.         this.phoneNB = phoneNB;
  64.     }
  65. 

  66.     public long getU_flow() {
  67.         return u_flow;
  68.     }
  69. 

  70.     public void setU_flow(long u_flow) {
  71.         this.u_flow = u_flow;
  72.     }
  73. 

  74.     public long getD_flow() {
  75.         return d_flow;
  76.     }
  77. 

  78.     public void setD_flow(long d_flow) {
  79.         this.d_flow = d_flow;
  80.     }
  81. 

  82.     public long getS_flow() {
  83.         return s_flow;
  84.     }
  85. 

  86.     public void setS_flow(long s_flow) {
  87.         this.s_flow = s_flow;
  88.     }
  89. 

  90. }
2.mapper中输出类型使用自定义的类型
  1. package com.apollo.mr.flowsum;
  2. 

  3. import org.apache.hadoop.io.LongWritable;
  4. import org.apache.hadoop.io.Text;
  5. import org.apache.hadoop.mapreduce.Mapper;
  6. 

  7. import java.io.IOException;
  8. 

  9. /**
  10.  * FlowBean 是我们自定义的一种数据类型，要在hadoop的各个节点之间传输，应该遵循hadoop的序列化机制
  11.  * 就必须实现hadoop相应的序列化接口
  12.  * Created by 85213 on 2016/12/13.
  13.  */
  14. public class FlowMapper extends Mapper<LongWritable,Text,Text,FlowBean> {
  15.     //拿到日志中的一行数据，切分各个字段，抽取出我们需要的字段：手机号，上行流量，下行流量，然后封装成kv发送出去
  16.     @Override
  17.     protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
  18.         //拿到一行数据
  19.         String line = value.toString();
  20.         //解析字段
  21.         String[] fileds = line.split("\t");
  22.         String phoneNB = fileds[1];
  23.         long u_flow = Long.parseLong(fileds[7]);
  24.         long d_flow = Long.parseLong(fileds[8]);
  25. 

  26.         context.write(new Text(phoneNB),new FlowBean(phoneNB,u_flow,d_flow));
  27. 

  28.     }
  29. }
3.reducer中输出自定义的类型还需要在自定义类型中实现头string()方法
  1. package com.apollo.mr.flowsum;
  2. 

  3. import org.apache.hadoop.io.Text;
  4. import org.apache.hadoop.mapreduce.Reducer;
  5. 

  6. import java.io.IOException;
  7. 

  8. /**
  9.  * Created by 85213 on 2016/12/13.
  10.  */
  11. public class FlowReducer extends Reducer<Text,FlowBean,Text,FlowBean> {
  12.     @Override
  13.     protected void reduce(Text key, Iterable<FlowBean> values, Context context) throws IOException, InterruptedException {
  14.         long u_flow_counter = 0;
  15.         long d_flow_counter = 0;
  16.         for(FlowBean value : values){
  17.             u_flow_counter += value.getU_flow();
  18.             d_flow_counter += value.getD_flow();
  19.         }
  20.         context.write(key,new FlowBean(key.toString(),u_flow_counter,d_flow_counter));
  21.     }
  22. }
4.标准的runner
  1. package com.apollo.mr.flowsum;
  2. 

  3. import org.apache.hadoop.conf.Configuration;
  4. import org.apache.hadoop.conf.Configured;
  5. import org.apache.hadoop.fs.Path;
  6. import org.apache.hadoop.io.Text;
  7. import org.apache.hadoop.mapreduce.Job;
  8. import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
  9. import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
  10. import org.apache.hadoop.util.Tool;
  11. import org.apache.hadoop.util.ToolRunner;
  12. 

  13. /**
  14.  * Created by 85213 on 2016/12/13.
  15.  */
  16. public class FlowRunner extends Configured implements Tool {
  17.     @Override
  18.     public int run(String[] strings) throws Exception {
  19.         Configuration conf = new Configuration();
  20.         Job job = Job.getInstance(conf);
  21. 

  22.         job.setJarByClass(FlowRunner.class);
  23. 

  24.         job.setMapperClass(FlowMapper.class);
  25.         job.setReducerClass(FlowReducer.class);
  26. 

  27.         job.setMapOutputKeyClass(Text.class);
  28.         job.setMapOutputValueClass(FlowBean.class);
  29. 

  30.         job.setOutputKeyClass(Text.class);
  31.         job.setOutputValueClass(FlowBean.class);
  32. 

  33.         FileOutputFormat.setOutputPath(job,new Path(strings[0]));
  34.         FileInputFormat.setInputPaths(job,new Path(strings[1]));
  35. 

  36.         return job.waitForCompletion(true)?0:1;
  37.     }
  38. 

  39.     public static void main(String[] args) throws Exception {
  40.         int res = ToolRunner.run(new Configuration(),new FlowRunner(),args);
  41.         System.exit(res);
  42.     }
  43. }

Hadoop的自定义排序

mr中的排序是在reducer阶段按照key的值排序的
1.实现comparable接口
  1. package com.apollo.mr.flowsum;
  2. 

  3. import org.apache.hadoop.io.WritableComparable;
  4. 

  5. import java.io.DataInput;
  6. import java.io.DataOutput;
  7. import java.io.IOException;
  8. 

  9. /**
  10.  * Writable是序列化接口，Comparable是排序接口，MR中排序是按照key来排序的
  11.  * Created by 85213 on 2016/12/13.
  12.  */
  13. public class FlowBean implements WritableComparable<FlowBean> {
  14.     private String phoneNB;
  15.     private long u_flow;
  16.     private long d_flow;
  17.     private long s_flow;
  18. 

  19.     //在反序列化时，反射机制需要调用空参构造函数，所以显示定义了一个空参构造函数
  20.     public FlowBean(){}
  21. 

  22.     //为了对象数据的初始化方便，加入一个带参的构造函数
  23.     public FlowBean(String phoneNB,long u_flow,long d_flow){
  24.         this.phoneNB = phoneNB;
  25.         this.u_flow = u_flow;
  26.         this.d_flow = d_flow;
  27.         this.s_flow = u_flow+d_flow;
  28.     }
  29. 

  30.     //将对象数据序列化到流中
  31.     @Override
  32.     public void write(DataOutput out) throws IOException {
  33.         out.writeUTF(phoneNB);
  34.         out.writeLong(u_flow);
  35.         out.writeLong(d_flow);
  36.         out.writeLong(s_flow);
  37.     }
  38. 

  39.     //注意顺序要和序列化的顺序一致
  40.     @Override
  41.     public void readFields(DataInput in) throws IOException {
  42.         phoneNB = in.readUTF();
  43.         u_flow = in.readLong();
  44.         d_flow = in.readLong();
  45.         s_flow = in.readLong();
  46.     }
  47. 

  48.     //排序规则，这里实现倒序排序
  49.     @Override
  50.     public int compareTo(FlowBean o) {
  51.         return s_flow > o.s_flow ?-1:1;
  52.     }
  53. 

  54.     public String toString() {
  55.         return "" + u_flow + "\t" +d_flow + "\t" + s_flow;
  56.     }
  57. 

  58.     public String getPhoneNB() {
  59.         return phoneNB;
  60.     }
  61. 

  62.     public void setPhoneNB(String phoneNB) {
  63.         this.phoneNB = phoneNB;
  64.     }
  65. 

  66.     public long getU_flow() {
  67.         return u_flow;
  68.     }
  69. 

  70.     public void setU_flow(long u_flow) {
  71.         this.u_flow = u_flow;
  72.     }
  73. 

  74.     public long getD_flow() {
  75.         return d_flow;
  76.     }
  77. 

  78.     public void setD_flow(long d_flow) {
  79.         this.d_flow = d_flow;
  80.     }
  81. 

  82.     public long getS_flow() {
  83.         return s_flow;
  84.     }
  85. 

  86.     public void setS_flow(long s_flow) {
  87.         this.s_flow = s_flow;
  88.     }
  89. 

  90. }
2.mr
  1. package com.apollo.mr.flowsort;
  2. 

  3. import com.apollo.mr.flowsum.FlowBean;
  4. import org.apache.hadoop.conf.Configuration;
  5. import org.apache.hadoop.fs.Path;
  6. import org.apache.hadoop.io.LongWritable;
  7. import org.apache.hadoop.io.NullWritable;
  8. import org.apache.hadoop.io.Text;
  9. import org.apache.hadoop.mapreduce.Job;
  10. import org.apache.hadoop.mapreduce.Mapper;
  11. import org.apache.hadoop.mapreduce.Reducer;
  12. import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
  13. import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
  14. 

  15. import java.io.IOException;
  16. 

  17. /**
  18.  * Created by 85213 on 2016/12/14.
  19.  */
  20. public class SortMR {
  21. 

  22.     public static class SortMapper extends Mapper<LongWritable,Text,FlowBean,NullWritable>{
  23.         @Override
  24.         protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
  25.             String line = value.toString();
  26.             String[] fields = line.split("\t");
  27.             String phoneNB = fields[0];
  28.             long u_flow = Long.parseLong(fields[1]);
  29.             long d_flow = Long.parseLong(fields[2]);
  30. 

  31.             context.write(new FlowBean(phoneNB,u_flow,d_flow),NullWritable.get());
  32.         }
  33.     }
  34.     public static class SortReducer extends Reducer<FlowBean,NullWritable,Text,FlowBean> {
  35.         @Override
  36.         protected void reduce(FlowBean key, Iterable<NullWritable> values, Context context) throws IOException, InterruptedException {
  37.             String phoneNB = key.getPhoneNB();
  38.             context.write(new Text(phoneNB),key);
  39.         }
  40.     }
  41. 

  42.     public static void main(String[] args) throws Exception {
  43.         Configuration conf = new Configuration();
  44.         Job job = Job.getInstance(conf);
  45. 

  46.         job.setJarByClass(SortMR.class);
  47.         job.setMapperClass(SortMapper.class);
  48.         job.setReducerClass(SortReducer.class);
  49. 

  50.         job.setMapOutputKeyClass(FlowBean.class);
  51.         job.setMapOutputValueClass(NullWritable.class);
  52. 

  53.         job.setOutputKeyClass(Text.class);
  54.         job.setOutputValueClass(FlowBean.class);
  55. 

  56.         FileInputFormat.setInputPaths(job,new Path(args[0]));
  57.         FileOutputFormat.setOutputPath(job,new Path(args[1]));
  58. 

  59.         System.exit(job.waitForCompletion(true)?0:1);
  60. 

  61.     }
  62. }

MR的自定义分区

实现自定义的分组主要实现：1.自定义分区规则    2.设置reduce任务的并发数

 1.自定义分组规则
  1. package com.apollo.mr.areapartition;
  2. 

  3. import org.apache.hadoop.mapreduce.Partitioner;
  4. 

  5. import java.util.HashMap;
  6. 

  7. /**
  8.  * Created by 85213 on 2016/12/14.
  9.  */
  10. public class AreaPartitioner<KEY,VALUE> extends Partitioner<KEY,VALUE>{
  11.     private static HashMap<String,Integer> areaMap = new HashMap<>();
  12. 

  13.     static{
  14.         areaMap.put("135", 0);
  15.         areaMap.put("136", 1);
  16.         areaMap.put("137", 2);
  17.         areaMap.put("138", 3);
  18.         areaMap.put("139", 4);
  19.     }
  20.     //reducer阶段会聚合组号分配到不同的reducer中
  21.     @Override
  22.     public int getPartition(KEY key, VALUE value, int i) {
  23.         //从key中拿到手机号，查询手机归属地字典，不同的省份返回不同的组号
  24.         int areaCoder  = areaMap.get(key.toString().substring(0, 3))==null?5:areaMap.get(key.toString().substring(0, 3));
  25.         return areaCoder;
  26.     }
  27. }
2.设置reduce的并发任务数量
  1. package com.apollo.mr.areapartition;
  2. 

  3. import com.apollo.mr.flowsum.FlowBean;
  4. import org.apache.hadoop.conf.Configuration;
  5. import org.apache.hadoop.fs.Path;
  6. import org.apache.hadoop.io.LongWritable;
  7. import org.apache.hadoop.io.Text;
  8. import org.apache.hadoop.mapreduce.Job;
  9. import org.apache.hadoop.mapreduce.Mapper;
  10. import org.apache.hadoop.mapreduce.Reducer;
  11. import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
  12. import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
  13. 

  14. import java.io.IOException;
  15. 

  16. /**
  17.  * 对流量原始日志进行流量统计，将不同省份的用户统计结果输出到不同文件
  18.  * 需要自定义改造两个机制：
  19.  * 1、改造分区的逻辑，自定义一个partitioner
  20.  * 2、自定义reduer task的并发任务数
  21.  * Created by 85213 on 2016/12/14.
  22.  */
  23.     public class FlowSumArea {
  24. 

  25.     public static class FlowSumAreaMapper extends Mapper<LongWritable,Text,Text,FlowBean>{
  26.         @Override
  27.         protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
  28.             String line = value.toString();
  29. 

  30.             String[] fields = line.split("\t");
  31.             String phoneNB = fields[1];
  32.             long u_flow = Long.parseLong(fields[7]);
  33.             long d_flow = Long.parseLong(fields[8]);
  34. 

  35.             context.write(new Text(phoneNB),new FlowBean(phoneNB,u_flow,d_flow));
  36.         }
  37.     }
  38. 

  39.     public static class FlowSumAreaReducer extends Reducer<Text,FlowBean,Text,FlowBean>{
  40.         @Override
  41.         protected void reduce(Text key, Iterable<FlowBean> values, Context context) throws IOException, InterruptedException {
  42.             long u_flow_count = 0;
  43.             long d_flow_count= 0;
  44.             for(FlowBean flowBean : values){
  45.                 u_flow_count += flowBean.getU_flow();
  46.                 d_flow_count += flowBean.getU_flow();
  47.             }
  48.             context.write(key,new FlowBean(key.toString(),u_flow_count,d_flow_count));
  49.         }
  50.     }
  51. 

  52.     public static void main(String[] args) throws Exception {
  53.         Configuration conf = new Configuration();
  54.         Job job = Job.getInstance(conf);
  55. 

  56.         job.setJarByClass(FlowSumArea.class);
  57.         job.setMapperClass(FlowSumAreaMapper.class);
  58.         job.setReducerClass(FlowSumAreaReducer.class);
  59. 

  60.         //设置我们自定义的分组逻辑定义
  61.         job.setPartitionerClass(AreaPartitioner.class);
  62.         //设置reduce的任务并发数，应该跟分组的数量保持一致
  63.         job.setNumReduceTasks(6);
  64. 

  65.         job.setMapOutputKeyClass(Text.class);
  66.         job.setMapOutputValueClass(FlowBean.class);
  67.         job.setOutputKeyClass(Text.class);
  68.         job.setOutputValueClass(FlowBean.class);
  69. 

  70.         FileOutputFormat.setOutputPath(job,new Path(args[0]));
  71.         FileInputFormat.setInputPaths(job,new Path(args[1]));
  72. 

  73.         System.exit(job.waitForCompletion(true)?0:1);
  74.     }
  75. }

Hadoop中Combiner的使用

在MapReduce中，当map生成的数据过大时，带宽就成了瓶颈，怎样精简压缩传给Reduce的数据，有不影响最终的结果呢。有一种方法就是使用Combiner，Combiner号称本地的Reduce，Reduce最终的输入，是Combiner的输出。
  1.  @Override  
  2.     public int run(String[] arg0) throws Exception {  
  3.         Configuration conf = getConf();  
  4.           
  5.           
  6.         Job job = new Job(conf, "demo1");  
  7.         String inputPath = ArgsTool.getArg(arg0, "input");  
  8.         String outputPath = ArgsTool.getArg(arg0, "output");  
  9.           
  10.         FileInputFormat.addInputPath(job, new Path(inputPath));  
  11.         FileOutputFormat.setOutputPath(job, new Path(outputPath));  
  12.           
  13.         job.setJarByClass(Demo1.class);  
  14.         job.setMapperClass(DemoMap.class);  
  15.         job.setReducerClass(DemoReduce.class);  
  16.         //job.setCombinerClass(DemoReduce.class);  
  17.         job.setOutputKeyClass(Text.class);  
  18.         job.setOutputValueClass(IntWritable.class);  
  19.         return job.waitForCompletion(true)?0:1;  
  20.     }

Hadoop中的Shuffle


简要说明：

------------shuffler-----------------
一、map task shuffler
1.partition,分区 
2.sort,排序
[3.combiner,合并]默认情况下没有combiner（合并内存中数据）

4.merge on disk，合并小的溢写文件合并成一个大文件

二、fetch/copy shuffler
1.reduce从所有的maptask的文件按照分区号抓取数据。

三、reduce shuffler
1.sort，因为从各个maptask取过来的数据所以数据已经乱了，二次排序
2.group,分组 默认分组算法是根据key相等为一组
------------shuffler-----------------

详细解说：


1.map输出后放在buffer in memory

2.partition
MapReduce提供Partitioner接口，它的作用就是根据key或value及reduce的数量来决定当前的这对输出数据最终应该交由哪个reduce task处理。默认对key hash后再以reduce task数量（默认一个MR的reduce task数量是1）取模。默认的取模方式只是为了平均reduce的处理能力，如果用户自己对Partitioner有需求，可以订制并设置到job上。 

接下来，需要将数据写入内存缓冲区中，缓冲区的作用是批量收集map结果，减少磁盘IO的影响。我们的key/value对以及Partition的结果都会被写入缓冲区。当然写入之前，key与value值都会被序列化成字节数组。
3.spill to disk
这个内存缓冲区是有大小限制的，默认是100MB。当map task的输出结果很多时，就可能会撑爆内存，所以需要在一定条件下将缓冲区中的数据临时写入磁盘，然后重新利用这块缓冲区。这个从内存往磁盘写数据的过程被称为Spill，中文可译为溢写，字面意思很直观。这个溢写是由单独线程来完成，不影响往缓冲区写map结果的线程。溢写线程启动时不应该阻止map的结果输出，所以整个缓冲区有个溢写的比例spill.percent。这个比例默认是0.8，也就是当缓冲区的数据已经达到阈值（buffer size * spill percent = 100MB * 0.8 = 80MB），溢写线程启动，锁定这80MB的内存，执行溢写过程。Map task的输出结果还可以往剩下的20MB内存中写，互不影响。
4.sort
当溢写线程启动后，需要对这80MB空间内的key做排序(Sort)。排序是MapReduce模型默认的行为，这里的排序也是对序列化的字节做的排序。 
5.combiner（对内存中的数据进行合并）
如果设置了combiner会启用执行分组函数
将有相同key的key/value对的value加起来，减少溢写到磁盘的数据量。
6.Merge(对大磁盘文件的合并)
每次溢写会在磁盘上生成一个溢写文件，如果map的输出结果真的很大，有多次这样的溢写发生，磁盘上相应的就会有多个溢写文件存在。当map task真正完成时，内存缓冲区中的数据也全部溢写到磁盘中形成一个溢写文件。最终磁盘中会至少有一个这样的溢写文件存在(如果map的输出结果很少，当map执行完成时，只会产生一个溢写文件)，因为最终的文件只有一个，所以需要将这些溢写文件归并到一起，这个过程就叫做Merge。
请注意，因为merge是将多个溢写文件合并到一个文件，所以可能也有相同的key存在，在这个过程中如果client设置过Combiner，也会使用Combiner来合并相同的key。 

------------------
1.Copy过程，简单地拉取数据。Reduce进程启动一些数据copy线程(Fetcher)，通过HTTP方式请求map task所在的TaskTracker获取map task的输出文件。因为map task早已结束，这些文件就归TaskTracker管理在本地磁盘中。 

2.Merge阶段。这里的merge如map端的merge动作，只是数组中存放的是不同map端copy来的数值。Copy过来的数据会先放入内存缓冲区中，这里的缓冲区大小要比map端的更为灵活，它基于JVM的heap size设置，因为Shuffle阶段Reducer不运行，所以应该把绝大部分的内存都给Shuffle用。这里需要强调的是，merge有三种形式：1)内存到内存  2)内存到磁盘  3)磁盘到磁盘。默认情况下第一种形式不启用，让人比较困惑，是吧。当内存中的数据量到达一定阈值，就启动内存到磁盘的merge。与map 端类似，这也是溢写的过程，这个过程中如果你设置有Combiner，也是会启用的，然后在磁盘中生成了众多的溢写文件。第二种merge方式一直在运行，直到没有map端的数据时才结束，然后启动第三种磁盘到磁盘的merge方式生成最终的那个文件。 

3.Sort排序，因为从各个maptask取过来的数据所以数据已经乱了，所以需要重新排序（二次排序)

4.Group分组，排序之后进行分组，默认按照key是否相等来决定是否是一组，一组数据对应一个reduce。

split的计算公式

MapReduce的 Split大小
– max.split(100M)
– min.split(10M)
– block(64M)
– max( min.split , min( max.split , block ))

 Mapreduce的输出进行压缩



 








MR实战：实现数据去重
howard2005的专栏
12-26 1756
本次实战任务旨在运用Hadoop MapReduce技术对含有重复数据的文本文件进行去重处理。我们启动Hadoop服务，创建并上传文件至HDFS，然后通过自定义Mapper和Reducer类实现去重操作。在Map阶段，我们将需要去重的数据设为key，value为空；在Reduce阶段，直接复制输入的key作为输出key，利用MapReduce自动去重。通过编写主类`DeduplicateDriver`设置参数并运行任务，我们将源文件去重后输出结果，从而提升对分布式计算的理解和应用能力。
MR调度算法
u013792289的博客
11-28 2233
MR的三种调度器：当job跑不完，资源利用率低的时候，可以采用这三种调度器： 1.FifoScheduler,默认的调度算法,先进先出的方式处理应用,只有一个队列可提交应用,没有应用优先级可以配置. 2.CapacityScheduler,容量调度器.多队列的,依靠作业,如果需求资源少了,优先级就会高一些,需求资源多了,优先级就会低一些. 3.FairScheduler:公平调度器,多队列的
mapreduce的shuffle机制（来自学习笔记）
weixin_34163741的博客
06-03 305
3. MAPREDUCE原理篇（2） 3.1 mapreduce的shuffle机制 3.1.1 概述： v mapreduce中，map阶段处理的数据如何传递给reduce阶段，是mapreduce框架中最关键的一个流程，这个流程就叫shuffle； vshuffle: 洗牌、发牌——（核心机制：数据分区，排序，缓存） v具体来说：就是将ma...
聊一聊MR的shuffle机制
想练武，就得下功夫
10-30 538
聊一聊MR的shuffle机制
MR之shuffle机制总结
weixin_42796403的博客
11-19 2172
MR之shuffle机制~分区 一、shuffle阶段划分 Map方法之后，Reduce方法之前的处理过程就是shuffle阶段.(sort-copy-sort) 二、shuffle阶段流程分析 相关基础：
洗牌算法shuffle
风先生的日常专栏
09-01 7276
将原来数组的数组进行打散，使原数组的某个数在打散后的数组中的每个位置上等概率的出现。很容易想到，需要用到随机数函数，而且应该是一个平均分布的随机数函数，还需要一个不放回的采样的生成模式。（1）random.seed([x]) 伪随机数生成模块。如果不提供 seed，默认使用系统时间。使用相同的 seed，可以获得完全相同的随机数序列，常用于算法改进测试。>>>from random import
shuffle算法
weixin_45594127的博客
02-16 1217
shuffle算法应用很多，比如n个元素里面随机抽取m个元素，最重要的特性就是我们要保证每个位置上出现任意一个数的概率都是1/n void shuffle(vector<int>&arr) { for (int i=arr.size()-1;i>=0;--i) { swap(arr[rand()%(i+1)],arr[i]); } } 对于arr[i],洗牌...
Hadoop详解(四)——Shuffle原理，Partitioner分区原理，Combiner编程，常见的MR算法
09-02 8503
Partitioner编程Partition简介shuffle是通过分区partitioner 分配给Reduce的 一个Reducer对应一个记录文件Partitioner是shuffle的一部分partitioner执行时机：在mapper执行完成，Reducer还没有执行的时候，mapper的输出就是partitioner的输入 即partitioner 分区主要是用来提高效率的 例如从全国
MapReduce框架下TF-IDF算法实现详解
综上所述，MapReduce模型与TF-IDF算法的结合实现了在大数据环境下的高效文本相似度计算。这不仅使得TF-IDF的应用范围得到了拓宽，而且也体现了分布式计算在处理大数据时的强大能力。通过理解并掌握MapReduce实现的TF...
10、Word2vec：学习词嵌入的Skip - Gram与CBOW算法实现
最新发布
ppp33的博客
08-07 65
本文详细介绍了Word2vec中经典的Skip-Gram和CBOW算法的实现过程。通过数据处理、模型定义、训练与评估等步骤，分别展示了两种算法的具体实现，并对它们的特点和适用场景进行了对比分析。文章还探讨了模型优化的方向，帮助读者更好地理解和应用这两种重要的词嵌入技术。
sparkshuffle和mrshuffle区别
03-16
sparkshuffle和mrshuffle都是用于分布式计算中的数据混洗（shuffle）操作，但是它们的实现方式和特点有所不同。 sparkshuffle是Apache Spark框架中的数据混洗实现，它采用了基于内存的计算模型，能够快速高效地处理...
MR图像分割算法
06-04
MR图像分割算法 MR图像分割算法 MR图像分割算法 MR图像分割算法
shuffle算法(洗牌算法)
u011878387的专栏
09-04 915
How to generate a shuffle list for 1,2,…,100? 思路如下: 1.初始化数组; 2.从后往前(或者从前往后,)产生一个随机数 3.这个随机数代表的含义,是当前位置可以交换的下标   改天写下code,面试忙啊
shuffle算法 c语言,C#Shuffle算法(洗牌算法、抽样算法)
weixin_29443363的博客
05-23 846
Fisher-Yates Shuffle算法1.创建一个新的list2.随机取出当前0-list.Count其中一个数3.把老list当前随机数位置添加到新list4.老list删除这个数5.直到老list.Count=0结束返回public void FisherYatesShuffle(List list){List cache = new List();int currentIndex;wh...
[算法9]shuffle算法
whzhcahzxh的专栏
08-28 1081
洗牌算法是一个
Fisher–Yates shuffle 算法详解：给定数组的乱序
qikaihuting的博客
10-13 5341
1、算法思想 根据维基百科解释：TheFisher–Yates shuffle is analgorithm for generating a random permutation of a finite sequence—in plain terms, the algorithm shuffles the sequence. The algorithm effective...
洗牌算法（Shuffle Algorithm）Fisher-Yates 洗牌算法详细解读
欢迎来到我的博客！这里是一个专注于计算机技术的分享平台，涵盖编程开发、算法研究、系统架构、软件工程等多个领域。无论你是初学者还是资深开发者，都能在这里找到有价值的内容。
10-25 5151
洗牌算法（Shuffle Algorithm）用于将一组元素随机打乱，类似于洗牌过程中将牌随机排列的过程。Fisher-Yates 洗牌算法是最经典且高效的洗牌算法，能够确保生成的排列是等概率的（即每一种排列出现的概率相同），其时间复杂度为 O(n)。
计算框架MR
china_demon的专栏
06-18 1770
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值