大数据之二MapReduce

最新推荐文章于 2023-03-09 16:45:06 发布

爱学习的老冰棍

最新推荐文章于 2023-03-09 16:45:06 发布

阅读量260

点赞数

分类专栏：大数据 Hadoop 文章标签：大数据 mapreduce

本文链接：https://blog.csdn.net/qq_43182741/article/details/108476508

版权

大数据同时被 2 个专栏收录

15 篇文章 0 订阅

订阅专栏

Hadoop

7 篇文章 0 订阅

订阅专栏

大数据之（二）MapReduce

3、MapReduce框架原理

3、MapReduce框架原理

3.1 InputFormat数据输入

MapReduce的数据流

3.1.1切片与MapTask并行度决定机制

MapTask的并行度决定Map阶段的任务处理并发度，进而影响到整个job的处理速度。
数据块：Block是HDFS物理上把数据分成一块一块。HDFS存储数据的单位是数据块。
数据切片：数据切片只是在逻辑上对输入进行分片，并不会在磁盘上将其切分成片进行存储。数据切片是MapReduce程序计算输入数据的单位，一个切片会对应启动一个MapTask。

数据切片与MapTask并行度决定机制

在这里插入图片描述

3.1.2 Job提交流程源码和切片源码详解

job提交流程源码详解

if (state == JobState.DEFINE) {
     submit();
   }
   // 1建立连接
	connect();	
		// 1）创建提交Job的代理
		new Cluster(getConfiguration());
			// （1）判断是本地运行环境还是yarn集群运行环境
			initialize(jobTrackAddr, conf); 
    // 2 提交job
    submitter.submitJobInternal(Job.this, cluster)
	// 1）创建给集群提交数据的Stag路径
	Path jobStagingArea = JobSubmissionFiles.getStagingDir(cluster, conf);
	// 2）获取jobid ，并创建Job路径
	JobID jobId = submitClient.getNewJobID();
	// 3）拷贝jar包到集群
    copyAndConfigureFiles(job, submitJobDir);	
	rUploader.uploadFiles(job, jobSubmitDir);
    // 4）计算切片，生成切片规划文件
    writeSplits(job, submitJobDir);
	maps = writeNewSplits(job, jobSubmitDir);
	input.getSplits(job);
    // 5）向Stag路径写XML配置文件
    writeConf(conf, submitJobFile);
	conf.writeXml(out);
    // 6）提交Job,返回提交状态
    status = submitClient.submitJob(jobId, submitJobDir.toString(), job.getCredentials());

总结一下：就是在job提交之前，
①首先进行了连接
②其次job将数据进行了切片以及读取成<k,v>的形式。
③生成了附件文件，包括把jar拷贝到了集群、生成了切片规划文件以及xml配置文件。

job提交流程源码解析，可参考下图

在这里插入图片描述

FileInputFormat切片源码解析，参考下图

在这里插入图片描述

在运行MapReduce程序时，输入的文件格式包括：基于行的日志文件、二进制格式文件、数据库表等。
FileInputFormat常用的接口实现类包括：TextInputFormat、KeyValueTextInputFormat、NLineInputFormat、CombineTextFormat和自定义InputFormat等。

3.2 MapReduce工作流程

MapReduce详细工作流程（一），参考下图

在这里插入图片描述

MapReduce详细工作流程（二）

在这里插入图片描述

上面的流程是整个MapReduce最全工作流程，但是shuffle过程只是第7步开始到第16步结束，具体shuffle过程详解，如下：
（1） MapTask收集我们的map()方法输出的kv对，放到内存缓冲区中
（2）从内存缓冲区不断溢出本地磁盘文件，可能会溢出多个文件
（3）多个溢出文件会被合并成大的溢出文件
（4）在溢出过程及合并的过程中，都要调用Partitioner进行分区和针对key进行排序
（5） ReduceTask根据自己的分区号，去各个MapTask机器上取相应的结果分区数据
（6） ReduceTask会抓取到同一个分区的来自不同MapTask的结果文件，ReduceTask会将这些文件在进行合并（归并排序）
（7）合并成大文件后，shuffle的过程就结束了，后面进入ReduceTask的逻辑运算过程。
注意：
①shuffle中的缓冲区大小会影响到MapReduce程序的执行效率，原则上说，缓冲区越大，磁盘io的次数越少，执行速度就越快。
②缓冲区的大小可以通过参数调整，参数：mapreduce.task.io.sort.mb默认是100M。

3.3 shuffle机制

3.3.1 shuffle机制

Map方法之后，Reduce方法之前的数据处理过程称之为shuffle。可参考下图：

在这里插入图片描述

3.3.2 Partition分区

(1)默认Partitioner分区
默认分区是根据key的hashCode对ReduceTask个数取模得到的。用户没法控制那个key存储到那个分区
(2)自定义Partitioner步骤
①自定义类继承Partitioner，重写getPartition方法
②在job驱动中，设置自定义Partitioner
③自定义Partition后，根据需求设置相对应的ReduceTask的数量

案例实操
1）需求：将统计结果按照手机归属地不同省份输出到不同的文件中（分区）
（1）输入数据（可参考上篇文章）
（2）期望输出数据
手机号136、137、138、139开头都分别放到独立的4个文件中，其他开头的放到一个文件中。
2）代码展示(只需在序列化案例的基础上，添加一个分区类，然后修改一下driver类)

public class MyPartitioner extends Partitioner<Text, FlowBean> {
   private int prititioner = 0;
   @Override
   public int getPartition(Text text, FlowBean flowBean, int i) {
       String ph = text.toString().substring(0, 3);
       switch (ph){
           case "136":
               prititioner = 0;
               break;
           case "137":
               prititioner = 1;
               break;
           case "138":
               prititioner = 2;
               break;
           case "139":
               prititioner = 3;
               break;
           default:
               prititioner = 4;
       }
       return prititioner;
   }
}

修改driver类

public class PartitionerDriver {
   public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
       //获取job对象
       Configuration configuration = new Configuration();
       Job job = Job.getInstance(configuration);
       //设置driver的jar包
       job.setJarByClass(PartitionerDriver.class);
       //设置mapper和reducer的jar包
       job.setMapperClass(FlowMapper.class);
       job.setReducerClass(FlowReducer.class);
       //指定自定义数据分区
       job.setPartitionerClass(MyPartitioner.class);
       //设定分区数量
       job.setNumReduceTasks(5);
       //设置map的输出类型
       job.setMapOutputKeyClass(Text.class);
       job.setMapOutputValueClass(FlowBean.class);
       //设置最终kv的输出类型
       job.setOutputKeyClass(Text.class);
       job.setOutputValueClass(FlowBean.class);
       //设置输入输出路径
       FileInputFormat.setInputPaths(job,new Path("d:/input1"));
       FileOutputFormat.setOutputPath(job,new Path("d:/output1"));
       //提交
       boolean b = job.waitForCompletion(true);
       System.exit(b? 0 : 1);
   }
}

以上就可以将数据进行分区输出了

3.3.3 WritableComparable排序

1）排序概述
排序是MapReduce框架中最重要的操作之一。
MapTask和ReduceTask均会对数据按照key进行排序。该操作属于Hadoop的默认行为。任何应用程序中的数据均会被排序，而不管逻辑上是都需要。
默认是按照字典顺序排序，且实现该排序的方法是快速排序。
对于MapTask，它将处理的结果展示放到环形缓冲区，当环形缓冲区存储到使用率到80%后，对缓冲区中的数据进行一次快速排序，并将这些有序数据溢写到磁盘上，而当数据处理完毕后，它会对磁盘上所有文件进行归并排序。
对于ReduceTask，它从每个MapTask上远程拷贝相应的数据文件，如果文件大小超过一定阙值，则溢写磁盘上，否则存储在内存中。如果磁盘上文件数目达到一定阙值，则进行一次归并排序以生成一个更大的文件；如果内存中文件大小或者数目超过一定阙值，则进行一次合并后将数据溢写到磁盘上。当所有数据拷贝完毕后，ReduceTask统一对内存和磁盘上的所有数据进行一次归并排序。

2）自定义排序WritableComparable原理分析
bean对象作为key传输，需要实现WritableComparable接口重写compareTo方法，就可以实现排序。

3）WritableComparable排序案例实操
(1)需求：根据案例序列化产生的结果再次对总流量进行倒序排序。
(2)代码实现
javabean

public class FlowBean implements WritableComparable {
   private long upFlow;
   private long downFlow;
   private long sumFlow;
   @Override
   public String toString() {
       return "upFlow=" + upFlow +
               ", downFlow=" + downFlow +
               ", sumFlow=" + sumFlow;
   }
   public void set(long upFlow,long downFlow){
       this.upFlow = upFlow;
       this.downFlow = downFlow;
       this.sumFlow = upFlow + downFlow;
   }
   public long getUpFlow() {
       return upFlow;
   }
   public void setUpFlow(long upFlow) {
       this.upFlow = upFlow;
   }
   public long getDownFlow() {
       return downFlow;
   }
   public void setDownFlow(long downFlow) {
       this.downFlow = downFlow;
   }
   public long getSumFlow() {
       return sumFlow;
   }
   public void setSumFlow(long sumFlow) {
       this.sumFlow = sumFlow;
   }
   /**
    *序列化
    * @param dataOutput
    * @throws IOException
    */
   public void write(DataOutput dataOutput) throws IOException {
       dataOutput.writeLong(upFlow);
       dataOutput.writeLong(downFlow);
       dataOutput.writeLong(sumFlow);
   }
   /**
    * 反序列化
    * @param dataInput
    * @throws IOException
    */
   public void readFields(DataInput dataInput) throws IOException {
       upFlow= dataInput.readLong();
       downFlow = dataInput.readLong();
       sumFlow = dataInput.readLong();
   }
   @Override
   public int compareTo(Object o) {
       return Long.compare(((FlowBean)o).getSumFlow(),this.getSumFlow());
   }
}

mapper类

public class FlowMapper extends Mapper<LongWritable,Text,FlowBean,Text> {
  private Text ph = new Text();
  private FlowBean flowBean = new FlowBean();
   @Override
   protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
       String[] filds = value.toString().split(" ");
       ph.set(filds[0]);
       flowBean.set(
               Long.parseLong(filds[1]),
               Long.parseLong(filds[2])
       );
       context.write(flowBean,ph);
   }
}

reducer类

public class FlowReducer extends Reducer<FlowBean, Text,Text,FlowBean> {
   @Override
   protected void reduce(FlowBean key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
       for (Text value : values) {
           context.write(value,key);
       }
   }
}

driver类

public class FlowDriver {
   public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException {
       //获取job对象
       Configuration configuration = new Configuration();
       Job job = Job.getInstance(configuration);
       //设置driver的jar包
       job.setJarByClass(FlowDriver.class);
       //设置mapper和reducer的jar包
       job.setMapperClass(FlowMapper.class);
       job.setReducerClass(FlowReducer.class);
       //设置map的输出类型
       job.setMapOutputKeyClass(FlowBean.class);
       job.setMapOutputValueClass(Text.class);
       //设置最终kv的输出类型
       job.setOutputKeyClass(Text.class);
       job.setOutputValueClass(FlowBean.class);
       //设置输入输出路径
       FileInputFormat.setInputPaths(job,new Path("d:/output1"));
       FileOutputFormat.setOutputPath(job,new Path("d:/output2"));
       //提交
       boolean b = job.waitForCompletion(true);
       System.exit(b? 0 : 1);
   }
}

总结一下：理论知识学起来很很枯燥，但是确实是对自己很大的提升！！

爱学习的老冰棍

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
大数据之二MapReduce

大数据之（二）MapReduce3、MapReduce框架原理3.1 InputFormat数据输入3.1.1切片与MapTask并行度决定机制3.1.2 Job提交流程源码和切片源码详解3.2 MapReduce工作流程3.3 shuffle机制3.3.1 shuffle机制3.3.2 Partition分区3.3.3 WritableComparable排序3、MapReduce框架原理3.1 InputFormat数据输入MapReduce的数据流#mermaid-svg-AWHbmH73
复制链接

扫一扫