Hadoop学习笔记之MapReduce（二）

最新推荐文章于 2024-07-16 16:32:17 发布

孤独的偷学者

最新推荐文章于 2024-07-16 16:32:17 发布

阅读量244

点赞数

分类专栏：开发环境的搭建文章标签：大数据 hadoop mapreduce

本文链接：https://blog.csdn.net/qq_48238787/article/details/121573280

版权

开发环境的搭建专栏收录该内容

19 篇文章 1 订阅

订阅专栏

Hadoop系列文章：
Hadoop学习笔记之初始Hadoop
Hadoop学习笔记之HDFS
Hadoop学习笔记之MapReduce（一）
Hadoop学习笔记之MapReduce（二）
Hadoop学习笔记之Yarn

3 MapReduce 框架原理

MapReduce总体步骤：
在这里插入图片描述

3.1 InputFormat 数据输入

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

（1）问题引出
MapTask 的并行度决定 Map 阶段的任务处理并发度，进而影响到整个 Job 的处理速度。
思考：1G 的数据，启动 8 个 MapTask，可以提高集群的并发处理能力。那么 1K 的数据，也启动 8 个 MapTask，会提高集群性能吗？MapTask 并行任务是否越多越好呢？哪些因素影响了 MapTask 并行度？
MapTask的数量需要根据数据的大小来进行分配的，因为每开启一个MapTask就要节点给它申请一个container容器，并且申请资源等需要一定的时间，所有当数据量很小的时候开启多个MapTask并不能提高处理速度，反而会浪费资源，而且速度还可能更慢。

（2）MapTask 并行度决定机制

数据块：Block 是 HDFS 物理上把数据分成一块一块。数据块是 HDFS 存储数据单位。
数据切片：数据切片只是在逻辑上对输入进行分片，并不会在磁盘上将其切分成片进行存储。数据切片是 MapReduce 程序计算输入数据的单位，一个切片会对应启动一个 MapTask。

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

(1）Job 提交流程源码详解
在这里插入图片描述

(2）FileInputFormat 切片源码解析（input.getSplits(job)）

3.1.3 FileInputFormat 切片机制

在这里插入图片描述
FileInputFormat切片大小的参数配置

3.1.4 TextInputFormat

(1)FileInputFormat 实现类
思考：在运行 MapReduce 程序时，输入的文件格式包括：基于行的日志文件、二进制格式文件、数据库表等。那么，针对不同的数据类型，MapReduce 是如何读取这些数据的呢？
FileInputFormat 常见的接口实现类包括：TextInputFormat(常用)、KeyValueTextInputFormat、NLineInputFormat、CombineTextInputFormat（常用）和自定义 InputFormat 等。

（2）TextInputFormat
TextInputFormat 是默认的 FileInputFormat 实现类。按行读取每条记录。键是存储该行在整个文件中的起始字节偏移量， LongWritable 类型。值是这行的内容，不包括任何行终止符（换行符和回车符），Text 类型。

以下是一个示例，比如，一个分片包含了如下 4 条文本记录。

Rich learning form
Intelligent learning engine
Learning more convenient
From the real demand for more close to the enterprise

每条记录表示为以下键/值对：

(0,Rich learning form)
(20,Intelligent learning engine)
(49,Learning more convenient)
(74,From the real demand for more close to the enterprise)

3.1.5 CombineTextInputFormat 切片机制

框架默认的 TextInputFormat 切片机制是对任务按文件规划切片，不管文件多小，都会是一个单独的切片，都会交给一个 MapTask，这样如果有大量小文件，就会产生大量的MapTask，处理效率极其低下。

应用场景：
CombineTextInputFormat 用于小文件过多的场景，它可以将多个小文件从逻辑上规划到一个切片中，这样，多个小文件就可以交给一个 MapTask 处理。
虚拟存储切片最大值设置
CombineTextInputFormat.setMaxInputSplitSize(job, 4194304);// 4m
注意：虚拟存储切片最大值设置最好根据实际的小文件大小情况来设置具体的值。
切片机制
生成切片过程包括：虚拟存储过程和切片过程二部分。

（1）虚拟存储过程：
将输入目录下所有文件大小，依次和设置的 setMaxInputSplitSize 值比较，如果不大于设置的最大值，逻辑上划分一个块。如果输入文件大于设置的最大值且大于两倍，那么以最大值切割一块；当剩余数据大小超过设置的最大值且不大于最大值 2倍，此时将文件均分成 2 个虚拟存储块（防止出现太小切片）。
例如 setMaxInputSplitSize 值为 4M，输入文件大小为8.02M，则先逻辑上分成一个4M。剩余的大小为 4.02M，如果按照 4M 逻辑划分，就会出现 0.02M 的小的虚拟存储文件，所以将剩余的 4.02M 文件切分成（2.01M 和 2.01M）两个文件。
（2）切片过程：
（a）判断虚拟存储的文件大小是否大于 setMaxInputSplitSize 值，大于等于则单独形成一个切片。
（b）如果不大于则跟下一个虚拟存储文件进行合并，共同形成一个切片。
（c）测试举例：有 4 个小文件大小分别为 1.7M、5.1M、3.4M 以及 6.8M 这四个小文件，则虚拟存储之后形成 6 个文件块，大小分别为：
1.7M，（2.55M、2.55M），3.4M 以及（3.4M、3.4M）
最终会形成 3 个切片，大小分别为：
（1.7+2.55）M，（2.55+3.4）M，（3.4+3.4）M

3.1.6 CombineTextInputFormat 案例实操

需求:将输入的大量小文件合并成一个切片统一处理
(1)输入数据：准备四个小文件

（2）期望：一个切片处理 4 个文件
实现过程
（1）不做任何处理，运行 1.8 节的 WordCount 案例程序，观察切片个数为 4。

而且可以在控制台输出的内容找到每个对应MapTash与ReduceTask的日志：

还有第三个第四个MapTask，这里就不再展示了

因为我们没有设置Reducenum的值，所以默认只有一个ReduceTask。

（2）在 WordcountDriver 中增加如下代码，运行程序，并观察运行的切片个数为 3
```
// 如果不设置 InputFormat，它默认用的是 TextInputFormat.class
job.setInputFormatClass(CombineTextInputFormat.class);
//虚拟存储切片最大值设置 6kb,我这里数据比较小，你们可以找几个大一点的文件
CombineTextInputFormat.setMaxInputSplitSize(job, 6144);
```

现在只有三个MapTask了：在这里插入图片描述
虚拟存储阶段：5kb、4.5kb、4.5kb、4.5kb、4.5kb、1kb
切片结果：（5+4.5）kb、（4.5+4.5）kb、（4.5+1）kb

3.2 MapReduce 工作流程

MapReduce详细工作流程
在这里插入图片描述

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

3.3 Shuffle 机制

3.3.1 Shuffle 机制

Map 方法之后，Reduce 方法之前的数据处理过程称之为 Shuffle。
在这里插入图片描述

3.3.2 Partition 分区

在这里插入图片描述

3.3.3 Partition 分区案例实操

需求：
将统计结果按照手机归属地不同省份输出到不同文件中（分区）
期望输出数据：手机号 136、137、138、139 开头都分别放到一个独立的 4 个文件中，其他开头的放到
一个文件中。
需求分析

在案例 2.3 的基础上，增加一个分区类

import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Partitioner;
public class ProvincePartitioner extends Partitioner<Text, Flowbean> {
    @Override
    public int getPartition(Text text, Flowbean flowBean, int numPartitions)
    {
        //获取手机号前三位 prePhone
        String phone = text.toString();
        String prePhone = phone.substring(0, 3);
        //定义一个分区号变量 partition,根据 prePhone 设置分区号
        int partition;
        if("136".equals(prePhone)){
            partition = 0;
        }else if("137".equals(prePhone)){
            partition = 1;
        }else if("138".equals(prePhone)){
            partition = 2;
        }else if("139".equals(prePhone)){
            partition = 3;
        }else {
            partition = 4;
        }
        //最后返回分区号 partition
        return partition;
    }
}

在驱动函数中增加自定义数据分区设置和 ReduceTask 设置
输出结果共有五个文件

五个文件内容如下：

3.3.4 WritableComparable 排序

排序概述
排序是MapReduce框架中最重要的操作之一。MapTask和ReduceTask均会对数据按照key进行排序。该操作属于Hadoop的默认行为。任何应用程序中的数据均会被排序，而不管逻辑上是否需要。默认排序是按照字典顺序排序，且实现该排序的方法是快速排序。

对于MapTask，它会将处理的结果暂时放到环形缓冲区中，当环形缓冲区使用率达到一定阈值后，再对缓冲区中的数据进行一次快速排序，并将这些有序数据溢写到磁盘上，而当数据处理完毕后，它会对磁盘上所有文件进行归并排序。

对于ReduceTask，它从每个MapTask上远程拷贝相应的数据文件，如果文件大小超过一定阈值，则溢写磁盘上，否则存储在内存中。如果磁盘上文件数目达到一定阈值，则进行一次归并排序以生成一个更大文件；如果内存中文件大小或者数目超过一定阈值，则进行一次合并后将数据溢写到磁盘上。当所有数据拷贝完毕后， ReduceTask统一对内存和磁盘上的所有数据进行一次归并排序。

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

3.3.5 WritableComparable 排序案例实操（全排序）

需求分析：
代码实现
1. FlowBean 对象在在需求 1 基础上增加了比较功能，并且实现的接口不一样了
Mapper阶段的输出K为Flowbean类型，V为Text（电话号码）
reducer阶段的功能就是将Mapper阶段的KV调换位置，循环写出的目的是避免总流量相同的情况
driver文件没有改动

结果：
在这里插入图片描述

3.3.6 WritableComparable 排序案例实操（区内排序）

需求：要求每个省份手机号输出的文件中按照总流量内部排序。
需求分析：基于前一个需求，增加自定义分区类，分区按照省份手机号设置。

案例实操

增加自定义分区类

import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Partitioner;
public class ProvincePartitioner2 extends Partitioner<FlowBean, Text> {
 @Override
 public int getPartition(FlowBean flowBean, Text text, int numPartitions) 
{
 //获取手机号前三位
 String phone = text.toString();
 String prePhone = phone.substring(0, 3);
 //定义一个分区号变量 partition,根据 prePhone 设置分区号
 int partition;
 if("136".equals(prePhone)){
 partition = 0;
 }else if("137".equals(prePhone)){
 partition = 1;
 }else if("138".equals(prePhone)){
 partition = 2;
 }else if("139".equals(prePhone)){
 partition = 3;
 }else {
 partition = 4;
 }
 //最后返回分区号 partition
 return partition;
 } }

在驱动类中添加分区类

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

3.3.7 Combiner 合并

在这里插入图片描述

3.4 OutputFormat 数据输出

3.4.1 OutputFormat 接口实现类

OutputFormat是MapReduce输出的基类，所有实现MapReduce输出都实现了 OutputFormat 接口。下面我们介绍几种常见的OutputFormat实现类。

OutputFormat实现类
默认输出格式TextOutputFormat
自定义OutputFormat
1. 应用场景：
  例如：输出数据到MySQL/HBase/Elasticsearch等存储框架中。
2. 自定义OutputFormat步骤
  自定义一个类继承FileOutputFormat。
  改写RecordWriter，具体改写输出数据的方法write()。

3.4.2 自定义 OutputFormat 案例实操

需求:过滤输入的 log 日志，包含 zjw的网站输出到 e:/atguigu.log，不包含 atguigu 的网站输出到 e:/other.log。
需求分析
案例实操
1. LogMapper

public class LogMapper extends Mapper<LongWritable, Text,Text, NullWritable> {

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
        // http://www.baidu.com
        //http://www.google.com
        // (http://www.google.com, NullWritable)
        // 不做任何处理
        context.write(value, NullWritable.get());
    }
}

LogReducer

public class LogReducer extends Reducer<Text, NullWritable, Text, NullWritable> {

    @Override
    protected void reduce(Text key, Iterable<NullWritable> values, Context context) throws IOException, InterruptedException {

        // http://www.baidu.com
        // http://www.baidu.com
        // 防止有相同数据，丢数据
        for (NullWritable value : values) {
            context.write(key, NullWritable.get());
        }
    }
}

LogOutputFormat

public class LogOutputFormat extends FileOutputFormat<Text, NullWritable> {
    @Override
    public RecordWriter<Text, NullWritable> getRecordWriter(TaskAttemptContext job) throws IOException, InterruptedException {

        LogRecordWriter lrw = new LogRecordWriter(job);

        return lrw;
    }
}

LogReducerWriter

public class LogRecordWriter extends RecordWriter<Text, NullWritable> {

    private  FSDataOutputStream atguiguOut;
    private  FSDataOutputStream otherOut;

    public LogRecordWriter(TaskAttemptContext job) {
        // 创建两条流
        try {
            FileSystem fs = FileSystem.get(job.getConfiguration());

            atguiguOut = fs.create(new Path("D:\\hadoop\\atguigu.log"));

            otherOut = fs.create(new Path("D:\\hadoop\\other.log"));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void write(Text key, NullWritable value) throws IOException, InterruptedException {
        String log = key.toString();

        // 具体写
        if (log.contains("atguigu")){
            atguiguOut.writeBytes(log+"\n");
        }else {
            otherOut.writeBytes(log+"\n");
        }
    }

    @Override
    public void close(TaskAttemptContext context) throws IOException, InterruptedException {
        // 关流
        IOUtils.closeStream(atguiguOut);
        IOUtils.closeStream(otherOut);
    }
}

LogDriver(除了以下部分，其它跟之前类似)

3.6 Join 应用

3.6.1 Reduce Join

Map 端的主要工作：为来自不同表或文件的 key/value 对，打标签以区别不同来源的记录。然后用连接字段作为 key，其余部分和新加的标志作为 value，最后进行输出。

Reduce 端的主要工作：在 Reduce 端以连接字段作为 key 的分组已经完成，我们只需要在每一个分组当中将那些来源于不同文件的记录（在 Map 阶段已经打标志）分开，最后进行合并就 ok 了。

3.6.2 Reduce Join 案例实操

需求：

将商品信息表中数据根据商品 pid 合并到订单数据表中。
需求分析

这种方式中，合并的操作是在 Reduce 阶段完成，Reduce 端的处理压力太大，Map节点的运算负载则很低，资源利用率不高，且在 Reduce 阶段极易产生数据倾斜。
解决方案：Map 端实现数据合并。

3.6.3 Map Join

使用场景
Map Join 适用于一张表十分小、一张表很大的场景。
优点
思考：在 Reduce 端处理过多的表，非常容易产生数据倾斜。怎么办？
在 Map 端缓存多张表，提前处理业务逻辑，这样增加 Map 端业务，减少 Reduce 端数
据的压力，尽可能的减少数据倾斜。

具体办法：采用 DistributedCache
（1）在 Mapper 的 setup 阶段，将文件读取到缓存集合中。
（2）在 Driver 驱动类中加载缓存。

//缓存普通文件到 Task 运行节点。
job.addCacheFile(new URI("file:///e:/cache/pd.txt"));
//如果是集群运行,需要设置 HDFS 路径
job.addCacheFile(new URI("hdfs://hadoop102:8020/cache/pd.txt"));
MapJoin 适用于关联表中有小表的情形。

实现代码
Map端表合并案例分析（Distributedcache）

MapJoinMapper

public class MapJoinMapper extends Mapper<LongWritable, Text, Text, NullWritable> {
    private HashMap<String, String> pdMap = new HashMap<>();
    private Text outK = new Text();

    @Override
    protected void setup(Context context) throws IOException, InterruptedException {
        // 获取缓存的文件，并把文件内容封装到集合 pd.txt
        URI[] cacheFiles = context.getCacheFiles();

        FileSystem fs = FileSystem.get(context.getConfiguration());
        FSDataInputStream fis = fs.open(new Path(cacheFiles[0]));

        // 从流中读取数据
        BufferedReader reader = new BufferedReader(new InputStreamReader(fis, "UTF-8"));

        String line;
        while (StringUtils.isNotEmpty(line = reader.readLine())) {
            // 切割
            String[] fields = line.split("\t");

            // 赋值
            pdMap.put(fields[0], fields[1]);
        }

        // 关流
        IOUtils.closeStream(reader);
    }

    @Override
    protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {

        // 处理 order.txt
        String line = value.toString();

        String[] fields = line.split("\t");

        // 获取pid
        String pname = pdMap.get(fields[1]);

        // 获取订单id 和订单数量
        // 封装
        outK.set(fields[0] + "\t" + pname + "\t" + fields[2]);

        context.write(outK, NullWritable.get());
    }
}

在这里插入图片描述

孤独的偷学者

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
打赏
0
评论
Hadoop学习笔记之MapReduce（二）

3 MapReduce 框架原理MapReduce总体步骤：3.1 InputFormat 数据输入3.1.1 切片与 MapTask 并行度决定机制（1）问题引出 MapTask 的并行度决定 Map 阶段的任务处理并发度，进而影响到整个 Job 的处理速度。思考：1G 的数据，启动 8 个 MapTask，可以提高集群的并发处理能力。那么 1K 的数据，也启动 8 个 MapTask，会提高集群性能吗？MapTask 并行任务是否越多越好呢？哪些因素影响了 MapTask 并行度？
复制链接

扫一扫