Hadoop核心-MapRedce介绍与WordCount实践(单词计数与按单词长度分区)(Maven)

最新推荐文章于 2022-10-18 10:14:30 发布

珞清殇

最新推荐文章于 2022-10-18 10:14:30 发布

阅读量328

点赞数

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

本文链接：https://blog.csdn.net/qq_44992559/article/details/109554779

版权

大数据 Note 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

文章目录

一、概述

分布式并行编程

Google首先提出分布式并行编程模型MapReduce，Hadoop MapReduce是它的开源实现；
分布式程序运行在大规模计算机集群上，能够并行执行大规模数据处理任务而获得海量的计算能力；

MapReduce与传统的并行计算框架(eg. MPI)的比较(Why MapReduce?)

	传统并行计算框架	MapReduce
集群架构/容错性	共享式(共享内存/共享存储)，容错性差	非共享性，容错性好
硬件/价格/扩展性	刀片服务器、高速网、SAN，价格贵，扩展性差	普通PC，便宜，扩展性好
编程/学习难度	what-how，难	what，简单
适用场景	实时、细粒度计算、计算密集型	批处理、非实时、数据密集型

MapReduce模型简介
- MapReduce将复杂的，运行于大规模集群上的并行计算过程高度地抽象到了两个函数：Map和Reduce；
- MapReduce采用“分而治之”策略，存储在分布式文件系统中的大规模数据集，会被切分成许多独立的分片(split)，这些分片可以被多个Map任务并行处理；
- MapReduce设计的一个理念就是“计算向数据靠拢”，而不是“数据向计算靠拢”，因为移动数据需要大量的网络传输开销；
- MapReduce框架采用Master/Slave，包括一个Master和若干个Slave；
  - Master上运行JobTracker，Slave上运行TaskTracker；
- Hadoop框架是用Java实现的但MapReduce应用程序不一定要用Java来写；
Map和Reduce函数

二、MapReduce的体系结构

MapReduce体系结构主要由四个部分组成，分别是：Client、JobTracker、TaskTracker以及Task
- Client
  - 用户编写的MapReduce程序通过Client提交到JobTracker端；
  - 用户可通过Client提供的一些接口查看作业运行状态；
- JobTracker
  - JobTracker 负责资源监控和作业调度；
  - JobTracker 监控所有TaskTracker与Job的健康状况，一旦发现失败，就将相应的任务转移到其他节点；
  - JobTracker 会跟踪任务的执行进度、资源使用量等信息，并将这些信息告诉任务调度器(TaskScheduler)，而调度器会在资源出现空闲时，选择合适的任务去使用这些资源；
- TaskTraker
  - TaskTracker 会周期性地通过“心跳”把本节点上资源的使用情况和任务的运行进度汇报给JobTracker，同时接收JobTracker发送过来的命令并执行相应的操作(如启动新任务、杀死任务等).
  - TaskTracker 使用“slot”等量划分本节点上的资源量(CPU、内存等)：一个 Task 获取一个slot 后才有机会运行，而Hadoop调度器的作用就是将各个TaskTracker上的空闲slot分配给Task使用(slot 分为Map slot 和Reduce slot 两种，分别供MapTask 和Reduce Task 使用).
- Task
  - Task分为Map Task和Reduce Task，均由TaskTracker启动

三、MapReduce工作流程

工作流程概述
- 不同的Map任务之间不会进行通信；
- 不同的Reduce任务之间不会发生任何信息交换；
- 用户不能显示地重一台机器向另一台机器发送信息；
- 所有的数据交换都是通过MapReduce框架自身去实现的；
MapReduce 各个执行阶段

RR：Record Reader 记录阅读器
- Split(分片)
  - HDFS以固定大小的block为基本单位存储数据，而对于MapReduce而言，其处理单位是split；
  - split是一个逻辑概念，它自包含一些元数据信息，比如数据起始位置、数据长度、数据所在节点等；
  - split的划分方法完全由用户自己决定；
- Map任务的数量
  - Hadoop为每个split创建一个Map任务，split 的多少决定了Map任务的数目；
  - 大多数情况下，理想的分片大小是一个HDFS块；
- Reduce任务的数量
  - 最优的Reduce任务个数取决于集群中可用的reduce任务槽(slot)的数目；
  - 通常设置比reduce任务槽数目稍微小一些的Reduce任务个数以预留一些系统资源处理可能发生的错误；
Shuffle 过程详解
- Shuffle过程
- Map端的Shuffle过程
  - 每个Map任务分配一个缓存；
  - MapReduce默认100MB缓存；
  - 设置溢写比例0.8(防止Map任务的输出丢失)；
  - 分区默认采用哈希函数；
  - 排序是默认的操作；
  - 排序后可以合并(Combine)；
  - 合并不能改变最终结果；
    
    合并(Combine)和归并(Merge)的区别：
    
    两个键值对<“a”,1>和<“a”,1>，如果合并，会得到<“a”,2>，如果归并，会得到<“a”,<1,1>>
  - 在Map任务全部结束之前进行归并；
  - 归并得到一个大的文件，放在本地磁盘；
  - 文件归并时，如果溢写文件数量大于预定值(默认是3)则可以再次启动Combiner，少于3不需要；
  - JobTracker会一直监测Map任务的执行，并通知Reduce任务来领取数据；
- Reduce端的Shuffle过程
  - Reduce任务通过RPC向JobTracker询问Map任务是否已经完成，若完成，则领取数据；
  - Reduce领取数据先放入缓存，来自不同Map机器，先归并，再合并，写入磁盘；
  - 多个溢写文件归并成一个或多个大文件，文件中的键值对是排序的；
  - 当数据很少时，不需要溢写到磁盘，直接在缓存中归并，然后输出给Reduce；
MapReduce应用程序执行过程

四、实例分析：WordCount

WordCount程序任务
WordCount设计思路
- 首先，需要检查WordCount程序任务是否可以采用MapReduce来实现；
- 其次，确定MapReduce程序的设计思路；
- 最后，确定MapReduce程序的执行过程；
WordCount执行过程实例
2. (未定义Combine)
3. (定义Combine)

五、MapReduce的具体应用

各种计算问题
- 关系代数运算(选择、投影、并、交、差、连接)
- 分组与聚合运算
- 矩阵-向量乘法
- 矩阵乘法
Ex：用MapReduce实现关系的自然连接
- 假设有关系R(A，B)和S(B,C)，对二者进行自然连接操作；
- 使用Map过程，把来自R的每个元组<a,b>转换成一个键值对<b, <R,a>>，其中的键就是属性B的值(把关系R包含到值中，这样做使得我们可以在Reduce阶段，只把那些来自R的元组和来自S的元组进行匹配); 类似地，使用Map过程，把来自S的每个元组<b,c>，转换成一个键值对<b,<S,c>>；
- 所有具有相同B值的元组被发送到同一个Reduce进程中，Reduce进程的任务是，把来自关系R和S的、具有相同属性B值的元组进行合并；
- Reduce进程的输出则是连接后的元组<a,b,c>，输出被写到一个单独的输出文件；

六、MapReduce编程实践

任务要求-统计单词数
- 附：统计单词数的同时按照单词数分区
新建Maven项目，配置依赖

<dependencies>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-common</artifactId>
            <version>3.2.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-hdfs</artifactId>
            <version>3.2.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-mapreduce-client-common</artifactId>
            <version>3.2.1</version>
        </dependency>
        <dependency>
            <groupId>org.apache.hadoop</groupId>
            <artifactId>hadoop-mapreduce-client-core</artifactId>
            <version>3.2.1</version>
        </dependency>
    </dependencies>

新建WordCount类(略)
编写WordCount.java内部类TokenizerMapper：map处理逻辑

map输入类型为<key,value>，期望的map输出类型为<单词，出现次数>；

map输入类型最终确定为<Object,Test>，输出类型确定为<Test,IntWritable>；

public static class TokenizerMapper extends Mapper<Object, Text, Text, IntWritable> {
        private static final IntWritable one = new IntWritable(1);
        private final Text word = new Text();

        /*
        --------------
        key_in      value_in
        0           China is my motherland
        23          I love China
        0           I am from China # Another file
        -------------
        key_out     value_out
        China       1
        is          1
        my          1
        motherland  1
        I           1
        love        1
        China       1
        ......
        -------------
        Shuffle
        key_in      value_in
        China       <1,1,1>
        I           <1,1>
        am          <1>
        from        <1>
        is          <1>
        ...
         */
        @Override
        public void map(Object key, Text value, Mapper<Object, Text, Text, IntWritable>.Context context) throws IOException, InterruptedException {
            System.out.println("Begin map sentence:"+value.toString()+"(key:"+key.toString()+")");
            StringTokenizer itr = new StringTokenizer(value.toString());
            while (itr.hasMoreTokens()) {
                String str = itr.nextToken();
                this.word.set(str);
                context.write(this.word, one);
            }
        }
}

编写WordCount.java内部类TokenizerMapper：reduce()处理逻辑

在Reduce处理数据之前，Map的结果首先通过Shuffle阶段整理；

Reduce阶段的任务：对输入数字序列进行求和；

Reduce的输入数据为<key,Iterable容器>；

public static class IntSumReducer extends Reducer<Text, IntWritable, Text, IntWritable> {
        private final IntWritable result = new IntWritable();
        /*
        ------------
        key_in      value_in
        China       <1,1,1>
        I           <1,1>
        am          <1>
        from        <1>
        is          <1>
        ...
        ----------
        key_out     value_out
        China       3
        I           2
        am          1
        from        1
        is          1
        ...
         */
        @Override
        public void reduce(Text key, Iterable<IntWritable> values, Context context) throws IOException, InterruptedException {
            int sum = 0;
            IntWritable val;
            for (Iterator<IntWritable> i = values.iterator(); i.hasNext(); sum+=val.get()){
                val = i.next();
            }
            this.result.set(sum);
            context.write(key, this.result);
        }
}

编写Partitioner类，用于单词分区

public class WordPartitioner extends Partitioner<Text, IntWritable> {
    @Override
    public int getPartition(Text key, IntWritable value, int i) {
        if(key.toString().length() >= 3){
            return 0;
        }else{
            return 1;
        }
    }
}

编写main方法

package org.example.wordcount;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.TextInputFormat;
import org.apache.hadoop.mapreduce.lib.output.TextOutputFormat;
import org.apache.hadoop.util.Tool;
import org.apache.hadoop.util.ToolRunner;

/**
 * @author hadoop
 */
public class PartitionMain extends Configured implements Tool {

    @Override
    public int run(String[] strings) throws Exception {
        Job job = Job.getInstance(super.getConf(),"Word Counter");
        job.setJarByClass(PartitionMain.class);
        // Set read file's format
        job.setInputFormatClass(TextInputFormat.class);
        for (int i=0; i<strings.length-1; ++i){
            TextInputFormat.addInputPath(job, new Path(strings[i]));
        }

        // Set Mapper
        job.setMapperClass(WordCount.TokenizerMapper.class);
        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(IntWritable.class);

        // --- Shuffle: Partition
        job.setPartitionerClass(WordPartitioner.class); // This is for partion

        // Set Reducer
        job.setReducerClass(WordCount.IntSumReducer.class); 
        // Set reduce task number
        job.setNumReduceTasks(2); //This is for partion,too
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);

        // Set output file's format
        job.setOutputFormatClass(TextOutputFormat.class);
        TextOutputFormat.setOutputPath(job,new Path(strings[strings.length-1]));

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

    public static void main(String[] args) throws Exception {
        System.setProperty("HADOOP_USER_NAME", "hadoop");
        Configuration conf = new Configuration();
        conf.set("fs.defaultFS", "hdfs://master:9000");
        String[] argus = new String[]{"source/wordfileA.txt", "source/wordfileB.txt", "destination"};
        FileSystem fileSystem = FileSystem.get(conf);
        if(fileSystem.exists(new Path(argus[argus.length-1]))){
            System.out.println("Already exists, delete");
            // 递归删除
            fileSystem.delete(new Path(argus[argus.length-1]),true);
        }
        int run = ToolRunner.run(conf, new PartitionMain(), argus);
        System.exit(run);
    }
}

编译打包为jar，并运行
- IDEA->File->Project Structure
- Then：
- And Then：
- cd ~
- vim wordfileA.txt(内容如题)
- vim wordfileB.txt(内容如题)
- hdfs dfs -put wordfileA.txt source destination(确保HDFS用户目录下无source与destination目录，若有，删除or换目录名)
- hdfs dfs -put wordfileB.txt source destination
- hadoop jar app/mapreduce.jar org.example.mapreduce.WordCount source destination
  
  若出现Error: Could not find or load main class org.apache.hadoop.mapreduce.v2.app.MRAppMaster
  见CentOS7伪分布式配置
- 运行结果(未分区的结果)：hdfs dfs -cat detination/*

附-IDEA Maven项目打包方式：
点击IEDA最右侧mavan栏，选择LifeCycle，clean $\rightarrow$ package ，完成之后会现target目录，即jar所在目录
在这里插入图片描述

Source：Hadoop Course PPT of NEU

珞清殇

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Hadoop核心-MapRedce介绍与WordCount实践(单词计数与按单词长度分区)(Maven)

文章目录一、概述二、MapReduce的体系结构三、MapReduce工作流程四、实例分析：WordCount五、MapReduce的具体应用六、MapReduce编程实践一、概述分布式并行编程Google首先提出分布式并行编程模型MapReduce，Hadoop MapReduce是它的开源实现；分布式程序运行在大规模计算机集群上，能够并行执行大规模数据处理任务而获得海量的计算能力；MapReduce与传统的并行计算框架(eg. MPI)的比较(Why MapReduce?)
复制链接

扫一扫