MapReduce框架原理之 Shuffle 机制
文章目录
2、Shuffle 机制
文章太长，上一节在这里
2.3 Combiner 合并
1. Combiner概述
Combiner是MR程序中Mapper和Reducer之外的一种组件(可以选择配置，可有可无)，但Combiner组件的父类也是Reducer。当map阶段传给reduce阶段的数据过多时可以有选择性的配置Combiner功能以减小网络传输或磁盘读写压力。Combiner是对shuffle输出的数据先进行一次按key的合并再输出，Combiner和Reducer的区别在于运行的位置:
Combiner是在每一个MapTask所在的节点运行;
Reducer是接收全局所有Mapper的输出结果；
Combiner能够应用的前提是不能影响最终的业务逻辑，而且Combiner的输入kv要对应Mapper的输出kv，Combiner的输出kv也应该跟Reducer的输入kv类型要对应起来。如下情况（求平均值）不能开启Combiner
Mapper Reducer
3 5 7 ->(3+5+7)/3=5 (3+5+7+2+6)/5=23/5 不等于 (5+4)/2=9/2
2 6 ->(2+6)/2=4
Combiner的意义就是对每一个MapTask的输出进行局部汇总，以减小网络传输量。
2. 自定义Combiner 实现步骤
（1）自定义一个Combiner 继承Reducer，重写 reduce 方法
public class WordCountCombiner extends Reducer<Text, IntWritable, Text, IntWritable> {
private IntWritable outV = new IntWritable();
@Override
protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
int sum = 0;
for (IntWritable value : values) {
sum += value.get();
}
outV.set(sum);
context.write(key,outV);
}
}
（2）在Job驱动类中绑定自定义的Combiner
job.setCombinerClass(WordCountCombiner.class);
3 Combiner 合并实例（以wordcount程序为例）
统计过程中对每一个 MapTask 的输出进行局部汇总，以减小网络传输量，即采用Combiner 功能。
在wordcount程序上增加一个Combiner类
package cn.jiangyun.mapreduce.combiner;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
import java.io.IOException;
public class WordCountCombiner extends Reducer<Text,IntWritable,Text, IntWritable> {
private IntWritable outV = new IntWritable();
@Override
protected void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
int sum = 0;
for (IntWritable value : values) {
sum += value.get();
}
//封装outKV
outV.set(sum);
//写出outKV
context.write(key,outV);
}
}
在Job驱动类中绑定自定义的Combiner
// 指定需要使用哪个类作为combiner 的逻辑
job.setCombinerClass(WordCountCombiner.class);
结果如下。在支持Combiner时加入Combiner能使传输的“重复数据”大大减少，加快计算效率。
2.4 OutputFormat 数据输出
1. OutputFormat 接口实现类
OutputFormat是MapReduce输出的基类，所有实现MapReduce输出都实现了OutputFormat接口。下面我们介绍几种常见的OutputFormat实现类
其中最核心的是FileOutputFormat，默认的输出格式就是他下面的子类TextOutputFormat。
2. 自定义OutputFormat步骤
- 自定义一个类继承FileOutputFormat。
- 改写RecordWriter，具体改写输出数据的方法write()。
- 在驱动类设置自定义的outputformat
job.setOutputFormatClass(CustomOutputFormat.class);
应用场景：
例如：输出数据到MySQL/HBase/Elasticsearch等存储框架中。
2.5 MapReduce 内核源码解析
1. MapTask工作机制
（1）Read 阶段：MapTask 通过InputFormat 获得的RecordReader，从输入的 InputSplit 中解析出一个个key/value。
（2）Map 阶段：该节点主要是将解析出的key/value 交给用户编写的map()函数处理，并产生一系列新的key/value。
（3）Collect 收集阶段：在用户编写的map()函数中，当数据处理完成后，一般会调用OutputCollector.collect()输出结果。在该函数内部，它会将生成的 key/value 进行分区（调用Partitioner），并写入一个环形内存缓冲区中。
（4）Spill 阶段：即“溢写”，当环形缓冲区满后，MapReduce 会将数据写到本地磁盘上，生成一个临时文件。需要注意的是，将数据写入本地磁盘之前，先要对数据进行一次本地排序，并在必要时对数据进行合并、压缩等操作。
Spill溢写阶段详情：
步骤1：利用快速排序算法对缓存区内的数据进行排序，排序方式是，先按照分区编号Partition 进行排序，然后按照key 进行排序。这样，经过排序后，数据以分区为单位聚集在一起，且同一分区内所有数据按照key 有序。
步骤2：按照分区编号由小到大依次将每个分区中的数据写入任务工作目录下的临时文件output/spillN.out（N 表示当前溢写次数）中。如果用户设置了Combiner，则写入文件之前，还要对每个分区中的数据进行一次聚集操作。
步骤3：将分区数据的元信息写到内存索引数据结构SpillRecord中，其中每个分区的元信息包括在临时文件中的偏移量、压缩前数据大小和压缩后数据大小。如果当前内存索引大小超过1MB，则将内存索引写到文件output/spillN.out.index 中。
（5）Merge 阶段：当所有数据处理完成后，MapTask 对所有临时文件进行一次合并，以确保最终只会生成一个数据文件，并保存到文件output/file.out 中，同时生成相应的索引文件output/file.out.index。
在进行文件合并过程中，MapTask 以分区为单位进行合并。对于某个分区，它将采用多轮递归合并的方式。每轮合并mapreduce.task.io.sort.factor（默认10）个文件，并将产生的文件重新加入待合并列表中，对文件排序后，重复以上过程，直到最终得到一个大文件。
让每个MapTask 最终只生成一个数据文件，可避免同时打开大量文件和同时读取大量小文件产生的随机读取带来的开销。
2. ReduceTask 工作机制
（1）Copy 阶段：ReduceTask 从各个MapTask 上远程拷贝一片数据，并针对某一片数据，如果其大小超过一定阈值，则写到磁盘上，否则直接放到内存中。
（2）Sort 阶段：在远程拷贝数据的同时，ReduceTask 启动了两个后台线程对内存和磁盘上的文件进行合并，以防止内存使用过多或磁盘上文件过多。按照MapReduce 语义，用户编写reduce()函数输入数据是按key 进行聚集的一组数据。为了将key 相同的数据聚在一起，Hadoop 采用了基于排序的策略。由于各个MapTask 已经实现对自己的处理结果进行了局部排序，因此，ReduceTask 只需对所有数据进行一次归并排序即可。
（3）Reduce 阶段：reduce()函数将计算结果写到HDFS 上。
3. ReduceTask 并行度决定机制
从之前的文章我们知道MapTask并行度由切片个数决定，切片个数由输入文件和切片规则决定。并行度是影响mapreduce程序运行效率的重要因素。
ReduceTask 的并行度同样影响整个Job 的执行并发度和执行效率与MapTask的并发数由切片数决定不同，ReduceTask数量的决定是可以直接手动设置：
// 默认值是1，手动设置为4
job.setNumReduceTasks(4);
注意：
（1）ReduceTask=0，表示没有Reduce阶段，输出文件个数和Map个数一致。ReduceTask默认值是1，如果不设置则输出文件个数为一个。
（2）如果数据分布不均匀，就有可能在Reduce阶段产生数据倾斜（针对于多个reducetask输出时，有的文件数据可能很少，有的却很多）
（3）ReduceTask数量并不是任意设置，还要考虑业务逻辑需求，有些情况下，需要计算全局汇总结果，就只能有1个ReduceTask。
（4）具体多少个ReduceTask，需要根据集群性能而定。
此外，如果你在之前设置了分区，ReduceTask的不同参数会导致不同的结果：
（1）如果ReduceTask > getPartition，则会多产生几个空的输出文件part-r-000xx；
（2）如果1<ReduceTask <getPartition，则有一部分分区数据无处安放，会Exception；
（3）如果ReduceTask = 1，则不管MapTask端输出多少个分区文件，最终结果都交给这一个ReduceTask，最终也就只会产生一个结果文件part-r-00000。因为在MapTask的源码中，执行分区的前提是先判断ReduceNum个数是否大于1。不大于1肯定不执行，因为此时的分区已经没有意义。
4. MapTask & ReduceTask 源码解析
文字写出来没有层次，实在不好总结，直接上图吧。
（1）MapTask 源码解析总体流程
（2）ReduceTask 源码解析总体流程
 {
return id + "\t" + pname + "\t" + amount;
}
@Override
public void write(DataOutput out) throws IOException {
out.writeUTF(id);
out.writeUTF(pid);
out.writeInt(amount);
out.writeUTF(pname);
out.writeUTF(flag);
}
@Override
public void readFields(DataInput in) throws IOException {
this.id = in.readUTF();
this.pid = in.readUTF();
this.amount = in.readInt();
this.pname = in.readUTF();
this.flag = in.readUTF();
}
}
TableMapper.java
package cn.jiangyun.mapreduce.join.reducejoin;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.InputSplit;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.lib.input.FileSplit;
import java.io.IOException;
public class TableMapper extends Mapper<LongWritable,Text,Text,TableBean>
{
private String filename;
private Text outK = new Text();
private TableBean outV = new TableBean();
@Override
protected void setup(Context context) throws IOException, InterruptedException {
//获取对应文件名称
InputSplit split = context.getInputSplit();
FileSplit fileSplit = (FileSplit) split;
filename = fileSplit.getPath().getName();
}
@Override
protected void map(LongWritable key, Text value, Context context)
throws IOException, InterruptedException {
//获取一行
String line = value.toString();
//判断是哪个文件,然后针对文件进行不同的操作
if(filename.contains("order")){ //订单表的处理
String[] split = line.split("\t");
//封装outK
outK.set(split[1]);
//封装outV
outV.setId(split[0]);
outV.setPid(split[1]);
outV.setAmount(Integer.parseInt(split[2]));
outV.setPname("");
outV.setFlag("order");
}else { //商品表的处理
String[] split = line.split("\t");
//封装outK
outK.set(split[0]);
//封装outV
outV.setId("");
outV.setPid(split[0]);
outV.setAmount(0);
outV.setPname(split[1]);
outV.setFlag("pd");
}
//写出KV
context.write(outK,outV);
}
}
TableReducer.java
package cn.jiangyun.mapreduce.join.reducejoin;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
public class TableReducer extends Reducer<Text,TableBean,TableBean, NullWritable> {
@Override
protected void reduce(Text key, Iterable<TableBean> values, Context context) throws IOException, InterruptedException {
ArrayList<TableBean> orderBeans = new ArrayList<>();
TableBean pdBean = new TableBean();
for (TableBean value : values) {
//判断数据来自哪个表
if("order".equals(value.getFlag())){ //订单表
//创建一个临时TableBean 对象接收value
TableBean tmpOrderBean = new TableBean();
try {
BeanUtils.copyProperties(tmpOrderBean,value);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
//将临时TableBean 对象添加到集合orderBeans
orderBeans.add(tmpOrderBean);
}else { //商品表
try {
BeanUtils.copyProperties(pdBean,value);
} catch (IllegalAccessException e) {
e.printStackTrace();
} catch (InvocationTargetException e) {
e.printStackTrace();
}
}
}
//遍历集合orderBeans,替换掉每个orderBean 的pid 为pname,然后写出
for (TableBean orderBean : orderBeans) {orderBean.setPname(pdBean.getPname());
//写出修改后的orderBean 对象
context.write(orderBean,NullWritable.get());
}
}
}
TableDriver.java
package cn.jiangyun.mapreduce.join.reducejoin;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import java.io.IOException;
public class TableDriver {
public static void main(String[] args) throws IOException,
ClassNotFoundException, InterruptedException {
Job job = Job.getInstance(new Configuration());
job.setJarByClass(TableDriver.class);
job.setMapperClass(TableMapper.class);
job.setReducerClass(TableReducer.class);
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(TableBean.class);
job.setOutputKeyClass(TableBean.class);
job.setOutputValueClass(NullWritable.class);
FileInputFormat.setInputPaths(job, new Path("/input"));//改成自己的路径
FileOutputFormat.setOutputPath(job, new Path("/output"));//改成自己的路径
boolean b = job.waitForCompletion(true);
System.exit(b ? 0 : 1);
}
}
结果如下
2. Map Join（推荐）
Map Join适用于一张表十分小、一张表很大的场景。在上一节总结了Reduce Join的缺点：总结来说就是数据、效率不均衡。
为了解决在Reduce 端处理过多的表可能导致数据倾斜、影响效率的问题。 我们可以在Map端缓存多张表，提前处理业务逻辑，这样既减少了Reduce端数据的压力，又尽可能的降低了数据倾斜的缺陷。
具体解决办法：采用DistributedCache
（1）在Mapper的setup 阶段，将文件读取到缓存集合中。
（2）在Driver驱动类中加载缓存。
//缓存普通文件到Task 运行节点。
job.addCacheFile(new URI("file://"));
//如果是集群运行,还需要设置HDFS 路径
job.addCacheFile(new URI("hdfs-url"));
4. Map Join 实例
仍然使用上一小节的商品订单数据，实现同样的功能：将商品信息表中数据根据商品pid 合并到订单数据表中。
代码可以根据之前的reducejoin修改，我这里把完整的放下面：
MapJoinMapper.java
在MapJoinMapper 类中的setup 方法中读取缓存文件
注意：一定要导入正确的包
package cn.jiangyun.mapreduce.join.mapjoin;
import org.apache.commons.lang.StringUtils;
import org.apache.hadoop.fs.FSDataInputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IOUtils;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.URI;
import java.util.HashMap;
import java.util.Map;
public class MapJoinMapper extends Mapper<LongWritable,Text,Text, NullWritable>
{
private Map<String, String> pdMap = new HashMap<>();
private Text text = new Text();
//
//任务开始前将pd 数据缓存进pdMap
@Override
protected void setup(Context context) throws IOException,
InterruptedException {
//通过缓存文件得到小表数据pd.txt
URI[] cacheFiles = context.getCacheFiles();
Path path = new Path(cacheFiles[0]);
//获取文件系统对象,并开流
FileSystem fs = FileSystem.get(context.getConfiguration());
FSDataInputStream fis = fs.open(path);
//通过包装流转换为reader,方便按行读取
BufferedReader reader = new BufferedReader(new
InputStreamReader(fis, "UTF-8"));
//逐行读取，按行处理
String line;
while (StringUtils.isNotEmpty(line = reader.readLine())) {
//切割一行
//01 小米
String[] split = line.split("\t");
pdMap.put(split[0], split[1]);
}
//关流
IOUtils.closeStream(reader);
}
//
@Override
protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
//读取大表数据
//1001 01 1
String[] fields = value.toString().split("\t");
//通过大表每行数据的pid,去pdMap 里面取出pname
String pname = pdMap.get(fields[1]);
//将大表每行数据的pid 替换为pname
text.set(fields[0] + "\t" + pname + "\t" + fields[2]);
//写出
context.write(text,NullWritable.get());
}
}
MapJoinDriver.java
在MapJoinDriver 驱动类中添加缓存文件
package cn.jiangyun.mapreduce.join.mapjoin;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;
public class MapJoinDriver {
public static void main(String[] args) throws IOException, ClassNotFoundException, InterruptedException, URISyntaxException {
// 1 获取job 信息
Configuration conf = new Configuration();
Job job = Job.getInstance(conf);
// 2 设置加载jar 包路径
job.setJarByClass(MapJoinDriver.class);
// 3 关联mapper
job.setMapperClass(MapJoinMapper.class);
// 4 设置Map 输出KV 类型
job.setMapOutputKeyClass(Text.class);
job.setMapOutputValueClass(NullWritable.class);
// 5 设置最终输出KV 类型
job.setOutputKeyClass(Text.class);
job.setOutputValueClass(NullWritable.class);
// 加载缓存数据
job.addCacheFile(new URI("src/main/java/cn/jiangyun/mapreduce/join/mapjoin/pd.txt"));
// Map 端Join 的逻辑不需要Reduce 阶段，设置reduceTask 数量为0
job.setNumReduceTasks(0);
// 6 设置输入输出路径
FileInputFormat.setInputPaths(job, new Path("src/main/java/cn/jiangyun/mapreduce/join/mapjoin/order.txt"));
FileOutputFormat.setOutputPath(job, new Path("src/main/java/cn/jiangyun/mapreduce/join/mapjoin/output"));
// 7 提交
boolean b = job.waitForCompletion(true);
System.exit(b ? 0 : 1);
}
}
结果如下
总结：这种方式中，合并的操作是在Map阶段完成，因为Map join适用于一张表十分小、一张表很大的场景，所以我们把数据少的表作为缓存输入，数据多的表还是在Map阶段正常读取，然后通过大表每行数据的pid,去小表里面取出pname，将大表每行数据的pid 替换为pname，实现一一对应的替换。这样就完成了两张表的合并。
2.7 数据清洗（ETL）
1. 数据清洗定义
“ETL，是英文 Extract-Transform-Load 的缩写，用来描述将数据从来源端经过抽取Extract）、转换（Transform）、加载（Load）至目的端的过程。ETL 一词较常用在数据仓库，但其对象并不限于数据仓库。在运行核心业务MapReduce 程序之前，往往要先对数据进行清洗，清理掉不符合用户要求的数据。清理的过程只是简单的将不符合要求的数据剔除或替换，不涉及计算和合并，因而往往只需要运行Mapper程序，不需要运行Reduce 程序。
2. 数据清洗实例
去除日志中字段个数小于等于11 的日志。需要在Map 阶段对输入的数据根据规则进行过滤清洗。
这里大部分代码都一样，我仅给出Map清洗过程业务代码
@Override
protected void map(LongWritable key, Text value, Mapper.Context context) throws IOException, InterruptedException {
// 1 获取1 行数据
String line = value.toString();
// 2 解析日志
boolean result = parseLog(line,context);
// 3 日志不合法则退出
if (!result) {
return;
}
// 4 日志合法就直接写出
context.write(value, NullWritable.get());
}
// 2 封装解析日志的方法
private boolean parseLog(String line, Context context) {
// 1 截取
String[] fields = line.split(" ");
// 2 日志长度大于11 的为合法
if (fields.length > 11) {
return true;
}else {
return false;
}
}
1536
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
