MapReduce框架原理

江韵

已于 2022-11-14 11:31:00 修改

阅读量1.4k

点赞数 3

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

于 2022-11-13 17:53:30 首次发布

本文链接：https://blog.csdn.net/qq_46539293/article/details/127825711

版权

Hadoop 专栏收录该内容

8 篇文章 0 订阅

订阅专栏

MapReduce框架原理之 MapReduce 工作流程与 Shuffle 机制

文章目录

MapReduce框架原理之 MapReduce 工作流程与 Shuffle 机制

1、MapReduce 工作流程

在这里插入图片描述

mapreduce工作流程如下：
1. 客户端submit()前，根据待处理文本获取待处理数据的信息，然后根据参数配置，形成一个任务分配的规划。
2. 客户端根据上一步参数准备出 job.xml(任务参数配置信息)、job.split(任务分片信息)、xx.jar(任务jar包，本地模式不需要)，并向yarn提交。
3. yarn会开启一个MRAppMaster，让MRAppMaster读取客户端提交的信息(主要是job.split)，
然后对应的开启指定个数的MapTask。
4. MapTask启动后会用默认的继承自InputFormat的TextInputFormat，TextInputFormat中的方法RecorderReader去按行读入待处理文本，isSplit去判断文件是否支持切片。然后将读入的数据传给Mapper。
5. 在Mapper阶段执行用户的业务流程。MapTask 收集我们的map()方法输出的kv 对，放到outputCollector(环形(内存)缓冲区).
以下为shuffle阶段
6. 从内存缓冲区不断溢写至本地磁盘，可能会溢出多个文件。
7. 多个溢出文件会被合并成大的溢出文件。
8. 在溢出过程及合并的过程中，都要调用Partitioner 进行分区和针对key 进行排序。
9. ReduceTask 根据自己的分区号，去各个MapTask 机器上取相应的结果分区数据。
10. ReduceTask 会抓取到同一个分区的来自不同。MapTask 的结果文件，ReduceTask 会将这些文件再进行合并（归并排序）。
11. 合并成大文件后，Shuffle 的过程也就结束了，后面进入ReduceTask 的逻辑运算过程（从文件中取出一个一个的键值对Group，调用用户自定义的reduce()方法）。

注意：
（1）Shuffle 中的缓冲区大小会影响到MapReduce 程序的执行效率，原则上说，缓冲区越大，磁盘io 的次数越少，执行速度就越快。
（2）缓冲区的大小可以通过参数调整，参数：mapreduce.task.io.sort.mb 默认100M。

2、Shuffle 机制

Map 方法之后，Reduce 方法之前的数据处理过程称之为Shuffle。

2.1 Partition 分区

1. 默认Partitioner分区

分区是将结果按照条件输出到不同文件中（分区）。比如：将统计结果按照手机归属地不同省份输出到不同文件中（分区），方便后续处理。

//默认分区
public class HashPartitioner<K, V> extends Partitioner<K, V> {
	public int getPartition(K key, V value, int numReduceTasks) {
		return (key.hashCode() & Integer.MAX_VALUE) % numReduceTasks;
	}

}

默认分区是根据key的hashCode对ReduceTasks个数取模得到的。用户没法控制哪个key存储到哪个分区。

2. 自定义Partitioner步骤

(1) 自定义类继承Partitioner，重写getPartition()方法。

public class CustomPartitioner extends Partitioner<Text, FlowBean> {
	@Override
	public int getPartition(Text key, FlowBean value, int numPartitions) {
		// 控制分区代码逻辑
		… …
		return partition;
		
	}
}

（2）在Job驱动中，设置自定义Partitioner。

job.setPartitionerClass(CustomPartitioner.class);

（3）自定义Partition后，要根据自定义Partitioner的逻辑设置相应数量的ReduceTask。

job.setNumReduceTasks(5);

3. 分区总结

（1）如果ReduceTask的数量> getPartition的结果数，则会多产生几个空的输出文件part-r-000xx；
（2）如果1<ReduceTask的数量<getPartition的结果数，则有一部分分区数据无处安放，会Exception；
（3）如果ReduceTask的数量=1，则不管MapTask端输出多少个分区文件，最终结果都交给这一个ReduceTask，最终也就只会产生一个结果文件part-r-00000；
（4）分区号必须从零开始，逐一累加。

4. 实例分析

例如：假设自定义分区数为5，则
（1）job.setNumReduceTasks(1); 会正常运行，只不过会产生一个输出文件
（2）job.setNumReduceTasks(2); 会报错
（3）job.setNumReduceTasks(6); 大于5，程序会正常运行，会产生空文件

5. Partition 分区实例

将手机号136、137、138、139 开头都分别放到一个独立的4 个文件中，其他开头的放到一个文件中。
实现步骤

自定义一个分区

package cn.jiangyun.mapreduce.partitioner;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Partitioner;

/**
 * 1. 自定义一个分区继承Partitioner类
 * 2.重写getPartition方法，实现我们自己的分区逻辑
 * 3.在驱动类中指明（绑定）我们自己写的分区类,并根据自定义Partitioner的逻辑设置相应数量的ReduceTask
 */
public class CustomPartitioner extends Partitioner<Text, IntWritable> {

    @Override
    public int getPartition(Text text, IntWritable intWritable, int numPartitions) {
        //key为手机号，对key分成5个区136、137、138、139、其他
        String phone = text.toString();
        String prePhone = phone.substring(0, 3);//取前三位
        int partition;//定义分区
        switch (prePhone){
            case "136" :
                partition = 0;//分区0
                break;
            case "137" :
                partition = 1;//分区1
                break;
            case "138" :
                partition = 2;//分区2
                break;
            case "139" :
                partition = 3;//分区3
                break;
            default:
                partition = 4;//分区4
                break;
        }
        return partition;
    }
}

在驱动函数中增加自定义数据分区设置和ReduceTask 设置

//绑定自定义分区,根据自定义Partitioner的逻辑设置相应数量的ReduceTask
        job.setPartitionerClass(CustomPartitioner.class);
        job.setNumReduceTasks(5);//自定义分区分了五个

Maper类如下

package cn.jiangyun.mapreduce.partitioner;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;

public class PartitionMapper extends Mapper<LongWritable, Text,Text, IntWritable> {
    private Text outKey = new Text();
    private IntWritable outValue = new IntWritable(0);
    @Override
    protected void map(LongWritable key, Text value,Context context) throws IOException, InterruptedException {
        //1.获取一行
        String line = value.toString();
        //2.分割
        String[] split = line.split("\t");
        //3.只要手机号
        String phone = split[1];
        outKey.set(phone);
        context.write(outKey,outValue);
    }
}

结果如下
在这里插入图片描述

2.2 WritableComparable 排序

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

2. 排序分类
（1）部分排序： MapReduce根据输入记录的键对数据集排序。保证输出的每个文件内部有序。
（2）全排序：最终输出结果只有一个文件，且文件内部有序。实现方式是只设置一个ReduceTask。但该方法在处理大型文件时效率极低，因为一台机器处理所有文件，完全丧失了MapReduce所提供的并行架构。
（3）辅助排序(GroupingComparator分组)：在Reduce端对key进行分组。应用于：在接收的key为bean对象时，想让一个或几个字段相同（全部
字段比较不相同）的key进入到同一个reduce方法时，可以采用分组排序。
（4）二次排序：在自定义排序过程中，如果compareTo中的判断条件为两个即为二次排序。

3 WritableComparable 排序实例（全排序）
根据2.2 自定义序列化案例产生的结果，再次对总流量进行倒序排序。
输入时数据格式

手机号	上行总流量	下行总流量	总流量
13470253144	180	180	360
13509468723	7335	110349	117684
…	…	…	…

输出时的数据格式(根据总流量排序)

手机号	上行总流量	下行总流量	总流量
13509468723	7335	110349	117684
13975057813	11058	48243	59301
…	…	…	…

要求根据手机总消耗流量进行倒序排序
FlowBean.java

package cn.jiangyun.mapreduce.sort.sort1;

import org.apache.hadoop.io.Writable;
import org.apache.hadoop.io.WritableComparable;

import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;

/**
 * 定义一个bean对象类并实现Writable接口
 * 1、重写空参构造
 * 2、重写序列化方法和反序列化方法
 * 4、重写toString方法
 */
public class FlowBean implements WritableComparable<FlowBean> {
   
    //新加入的排序内容
    @Override
    public int compareTo(FlowBean o) {
        //按照总流量比较,倒序排列
        if(this.sumFlow > o.sumFlow){
            return -1;
        }else if(this.sumFlow < o.sumFlow){
            return 1;
        }else {
            return 0;
        }
    }
}

FlowMapper.java

package cn.jiangyun.mapreduce.sort.sort1;

import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;

public class FlowMapper extends Mapper<LongWritable, Text,FlowBean,Text> {
    private Text outValue = new Text();
    private FlowBean outKey = new FlowBean();
    @Override
    protected void map(LongWritable key, Text value,Context context) throws IOException, InterruptedException {
        //1.获取一行
        String line = value.toString();
        //2.分割
        String[] split = line.split("\t");
        //3.封装k,v
        outKey.setUpFlow(Long.parseLong(split[1]));//第二个为上行流量
        outKey.setDownFlow(Long.parseLong(split[2]));//第三个为下行流量
        outKey.setSumFlow();//必须先完成up和down的赋值才能进行这一步，否则结果不正确
        outValue.set(split[0]);第一个为手机号
        //5.写出
        context.write(outKey,outValue);
    }
}

FlowReducer.java

package cn.jiangyun.mapreduce.sort.sort1;

import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;

public class FlowReducer extends Reducer<FlowBean, Text, Text, FlowBean> {
    @Override
    protected void reduce(FlowBean key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
        //1.遍历集合取值，循环写出，避免总流量相同的情况
        for (Text value : values) {
            //调换KV 位置,反向写出
            context.write(value,key);
        }
    }
}

FlowDriver.java
修改如下几项，文件输入路径为2.2 自定义序列化案例产生的结果

//4.设置map阶段输出类型
        job.setMapOutputKeyClass(FlowBean.class);
        job.setMapOutputValueClass(Text.class);

        //5.设置最终输出类型
        job.setOutputValueClass(Text.class);
        job.setOutputValueClass(FlowBean.class);

        //6.设置输入输出路径
        FileInputFormat.setInputPaths(job,new Path("src/main/java/cn/jiangyun/mapreduce/sort/sort1/part-r-00000"));
        FileOutputFormat.setOutputPath(job,new Path("src/main/java/cn/jiangyun/mapreduce/sort/sort1/output"));

结果如下
在这里插入图片描述

3 WritableComparable 排序实例（全排序）
基于前一个需求，增加自定义分区类，分区按照手机号前三位进行设置。
CustomPartitioner.java

package cn.jiangyun.mapreduce.sort.sort2;

import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Partitioner;

/**
 * 1. 自定义一个分区继承Partitioner类
 * 2.重写getPartition方法，实现我们自己的分区逻辑
 * 3.在驱动类中指明（绑定）我们自己写的分区类,并根据自定义Partitioner的逻辑设置相应数量的ReduceTask
 */
public class CustomPartitioner extends Partitioner<FlowBean,Text> {

    @Override
    public int getPartition(FlowBean flowBean, Text text, int numPartitions) {
        //将手机号分成5个区136、137、138、139、其他
        String phone = text.toString();
        String prePhone = phone.substring(0, 3);//取前三位
        int partition;//定义分区
        switch (prePhone){
            case "136" :
                partition = 0;//分区0
                break;
            case "137" :
                partition = 1;//分区1
                break;
            case "138" :
                partition = 2;//分区2
                break;
            case "139" :
                partition = 3;//分区3
                break;
            default:
                partition = 4;//分区4
                break;
        }
        return partition;
    }
}

在驱动类中绑定分区类

// 设置自定义分区器 
job.setPartitionerClass(CustomPartitioner.class);
// 设置对应的ReduceTask 的个数 
job.setNumReduceTasks(5);

结果如下(没放全)
在这里插入图片描述

文章太长，下一节在这里

江韵

关注

3
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
MapReduce框架原理

MapReduce 工作流程与 Shuffle 机制，shuffle过程的分区和排序
复制链接

扫一扫

专栏目录