Hadoop(十一):组合任务概述和格式

组合任务概述

  • 一些复杂的任务很难由一个MR处理完成,所以一般需要将其拆分成为多个简单的MR子任务来执行。

  • MapReduce框架中对于这类的问题提供了几种方式进行任务执行流程的控制,主要包括以下几种方式:

    • 顺序组合式MapReduce任务

      • 前一个执行完,后面再执行

    • 依赖关系组合式MapReduce任务

      • 前面有多个执行完,后面再执行

    • 链式MapReduce任务

      • 在Map之前或者Reduce之后增加处理

    • 其中顺序组合式MapReduce任务可以经过变形成为迭代式的MapReduce任务。

顺序组合式MapReduce任务

  • 多个MR任务作为一个串进行执行,前一个MR的输出作为后一个MR的输入,自动的完成顺序化的执行。

  • 顺序组合式MR中:

    • 每一个子任务都需要专门的设置独立的配置代码(其实就是和普通的MR是一样的)

    • 安装任务的执行顺序设置job的运行顺序

    • 任务完成后所有的中间结果输出目录都可以进行删除操作。

  • 格式: MapReduce1 -> MapReduce2 -> MapReduce3....,

  • 每个子任务都必须调用job.waitForCompletion(true)等待job执行完成才可以--就是前一个执行完成,后面才可以开始执行。

    优点:结构简单,容易实现。

    缺点:由于后一个MR任务必须等待前一个MR任务完成才可以进行,导致集群利用率不高;无法实现多重依赖的关系(或者说多依赖关系的实现比较麻烦)。

package com.rzp.linemr;
​
​
import org.apache.hadoop.mapreduce.Job;
​
import java.io.IOException;
​
//测试组合mr任务的案例:wordcount案例的输出结果是按照keyword字典排序进行输出,修改成按出现次数排序
public class Demo1 {
​
    public static void main(String[] args) throws InterruptedException, IOException, ClassNotFoundException {
        //按顺序创建job1,job2...
        Job job1 = createJobByTimes(1);
        Job job2 = createJobByTimes(2);
        //开始执行,这里执行顺序一定要和组合MR的Job的执行顺序一直
​
        runJob(job1,1);
        runJob(job2,2);
        System.out.println("Job执行成功");
    }
​
    //执行Job,执行失败抛出异常
    public static void runJob(Job job,int times) throws InterruptedException, IOException, ClassNotFoundException {
        if (!job.waitForCompletion(true)){
            throw new RuntimeException("第"+times+"个job执行失败");
        }
    }
​
    /**
     * 创建job根据给定的参数times
     * times = 组合式MR任务中第几个job
     */public static Job createJobByTimes(int times){
        //和普通MR的Job创建一样,从InputFormant开始到OutputFormat给定
//TODO 创建Job
        return null;
    }
}

依赖关系组合式

  • Hadoop框架为复杂的数据依赖关系提供了一种组合式MapReduce作业的执行流程机制。

  • 其实就是MR3依赖于MR1和MR2的结果,但是MR1和MR2不互相依赖,可以同时进行,而如果用顺序式就做不到。

  • Hadoop通过Job和JobControl类为这些作业提供具体的编程方法。

    • Job除了维护配置信息外,还需要维护子任务的依赖关系

    • JobControl类主要用来控制整个作业的执行过程。JobControl是一个Runnable子类,通过线程来调用start方法进行作业的执行流程控制。

  • Job完整类名为: org.apache.hadoop.mapred.jobcontrol.Job

  • JobControl完整类名为: org.apache.hadoop.mapreduce.lib.jobcontrol.JobControl

  • 优点:实现相对而言简单,提高了集群利用率。

  • 缺点:需要自己实现job执行流管理(job失败后执行流失败等操作)

package com.rzp.linemr;
​
import org.apache.hadoop.mapreduce.lib.jobcontrol.ControlledJob;
import org.apache.hadoop.mapreduce.lib.jobcontrol.JobControl;
import org.apache.hadoop.mapreduce.Job;
​
import java.io.IOException;
​
public class Demo2 {
​
    public static void main(String[] args) throws IOException {
        //调用createControlledJob()把mapreduce.Job(普通的job)转换为可控制的ControlledJob对象
        ControlledJob job1 = createControlledJob(createJobByTimes(1));
        ControlledJob job2 = createControlledJob(createJobByTimes(2));
        ControlledJob job3 = createControlledJob(createJobByTimes(3));
        //指定依赖关系--job3依赖于job1和job2
        //addDependinJob会返回Boolean,可以用于验证
        job3.addDependingJob(job1);
        job3.addDependingJob(job2);
        //开始创建job的执行流
        JobControl jc = new JobControl("测试依赖关系组合式");
        //添加job,没有顺序
        jc.addJob(job1);
        jc.addJob(job2);
        jc.addJob(job3);
        //总的job个数
        int totalSize = jc.getReadyJobsList().size();
        //开始执行job流
        //因为继承了Runnable接口,可以直接调用run方法
        //jc.run();
        //更推荐使用Thread来执行
boolean succeeded = false; //job执行流是否成功执行的标志位
        try{
            new Thread(jc).start();
            while (!jc.allFinished()){
                //没有执行完,继续进行
                try {
                    Thread.sleep(30000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }finally {
            //停止执行
            jc.stop();
            if(jc.allFinished()&&jc.getSuccessfulJobList().size() == totalSize){
                //全部执行完,而且执行成功job个数和总的job个数相等,那么任务job执行陈工
                succeeded = true;
            }
        }
        System.out.println("job执行"+(succeeded?"成功":"失败"));
    }
​
    //把mapreduce.Job(普通的job)转换为可控制的ControlledJob对象
    public static ControlledJob createControlledJob (Job job) throws IOException {
        ControlledJob cj = new ControlledJob(job.getConfiguration());
        cj.setJob(job);//惊醒设置
        return cj;
    }
​
​
    //和普通MR的Job创建一样,从InputFormant开始到OutputFormat给定
    public static Job createJobByTimes(int times){
       //TODO 创建Job
        return null;
    }
}
​

链式MapReduce

  • 前两种方式都会有多个Job的启动和关闭,会消耗资源,而Map和Reduce都涉及IO操作,效率不高,因此可以使用链式MR。

  • 一个MR任务可能会有一些前处理和后处理,比如说文档倒序索引中可能前处理需要去掉一些“停用词”,后处理需要将一些同义词进行归并。

  • 链式MR:链式Mapper(ChainMapper)和链式Reducer(ChainReducer)来完成这种处理。这种作业的执行流程为:map1-->map2-...-->reducer-->map3-->map4-...

    • 链式MR要求一个链路中只能有一个reduce操作,可以有多个map操作。

  • 优点:对于前处理和后处理有要求的MR任务,减轻了操作,提高了效率。

  • 缺点:需要指定额外的参数信息(前两种方式,job本身写法和普通MR是一样的,只是在运行主程序上做了操作,但是这种就不同了)。

  • 创建完job后,需要使用hadoop提供的专门类设置链路中的map-reduce执行顺序。

    • 使用ChainMapper.addMapper添加Map阶段的mapper,按照添加顺序执行,

    • 在Reducer阶段必须先使用ChainReducer.setReducer添加reducer处理类,然后才可以使用ChainReducer.addMapper添加mapper处理类,也是按照添加顺序执行job。

package com.rzp.linemr;
​
​
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.mapred.JobConf;
import org.apache.hadoop.mapred.Mapper;
import org.apache.hadoop.mapred.lib.ChainMapper;
import org.apache.hadoop.mapred.lib.ChainReducer;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
​
import java.io.IOException;
​
public class Demo3 {
​
    public static void main(String[] args) throws Exception {
        Configuration conf1 = new Configuration();
        Job job1 = Job.getInstance(conf1,"job1");
        job1.setJarByClass(Demo3.class);
        FileInputFormat.addInputPath(job1,new Path(""));
​
        /**
         * 设置mapper
         * klass 对应mapper类
         * K1, V1, K2, V2---klass对应的输入、输出的类型
         * mapperConf mapper使用的编写信息
         *///添加第1个mapper
        ChainMapper.addMapper(JobConf job,
                Class<? extends Mapper<K1, V1, K2, V2>> klass,
                Class<? extends K1> inputKeyClass,
                Class<? extends V1> inputValueClass,
                Class<? extends K2> outputKeyClass,
                Class<? extends V2> outputValueClass,
        boolean byValue, JobConf mapperConf);
​
        //添加第2个mapper
        ChainMapper.addMapper(JobConf job,
                Class<? extends Mapper<K1, V1, K2, V2>> klass,
                Class<? extends K1> inputKeyClass,
                Class<? extends V1> inputValueClass,
                Class<? extends K2> outputKeyClass,
                Class<? extends V2> outputValueClass,
        boolean byValue, JobConf mapperConf);
​
        //添加reducer
        //输入值和上面的一样
        ChainReducer.setReducer(...);
​
        //添加reducer后续Mapper
        //格式也和上面的一样
        //注意reducer
        ChainReducer.addMapper(...);
​
        //设置总的输入输出路径
        job1.setJarByClass(Demo3.class);
        //TODO 添加map和reduce的输出key和value的类型
    }
}
​

 

猜你喜欢

转载自www.cnblogs.com/renzhongpei/p/12635278.html