多MapReduce任务

最新推荐文章于 2021-07-22 23:40:47 发布
最新推荐文章于 2021-07-22 23:40:47 发布
阅读量339 收藏 1
点赞数
分类专栏： 大数据 文章标签： 多MapReduce 写HFile SplitRegions时长过长 Compacte性能 MapReduce分组排序分区
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ITwangnengjie/article/details/103270280
版权

在写HFile过程中：

1）因为存在相同rowkey的数据有很多，存在大的时间戳数据覆盖小的时间戳数据的情况；

2）还有如果全部数据都写成HFile，生成的HDFS数据集会很大，以本代码为案例，每次生成2T的数据量；

3）所有数据导入到HBase之后，HBase会根据HFile最大存储值进行SplitRegions。这会导致HBase表性能受限。

4）所有的数据覆盖处理，都由HBase的compaction完成，减弱HBase性能。

【

Compaction：

 在HBase中，每当memstore的数据flush到磁盘后，就形成一个storefile，当storefile的数量越来越大时，会严重影响HBase的读性能 ，所以必须将过多的storefile文件进行合并操作。Compaction是Buffer-flush-merge的LSM-Tree模型的关键操作，主要起到如下几个作用：

（1）合并文件

（2）清除删除、过期、多余版本的数据

（3）提高读写数据的效率
HBase中实现了两种Compaction：

这两种compaction方式的区别是：

<1> Minor操作只用来做部分文件的合并操作以及包括minVersion=0并且设置ttl的过期版本清理，不做任何删除数据、多版本数据的清理工作。

<2>Major操作是对Region下的HStore下的所有StoreFile执行合并操作，最终的结果是整理合并出一个文件。
】

针对这个在写HFile过程中遇到的问题，我的解决方案是：

在MR代码中，增加过滤过期时间戳的数据，代码完成Compaction过程，并减少总的数据量，为HBaseSplit和Compaction减少性能压力。主要用到MR的自定义分组排序分区功能。

下面是我的代码

分组排序类：

package com.xxx.xxx.xxx.xxx.usepartition.getrecentnewmileage;

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

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

/**
 * implements WritableComparable<StrTimeWritable>
 * 以str+time进行reduce排序分组
 * 按str 分组 然后组内按time排序
 */
public class StrTimeWritable implements WritableComparable<StrTimeWritable> {//implements Writable{

    public String getStr() {
        return str;
    }

    public void setStr(String str) {
        this.str = str;
    }

    public int getTime() {
        return time;
    }

    public void setTime(int time) {
        this.time = time;
    }

    public String str;
    public int time;
    public StrTimeWritable(String str,int time){
        this.str = str ;
        this.time = time ;
    }
    // 如果空构造函数被覆盖，一定要显示的定义一下，否则反序列化时会抛异常。
    public StrTimeWritable(){

    }
    @Override
    public void write(DataOutput dataOutput) throws IOException {
        dataOutput.writeUTF(str);
        dataOutput.writeInt(time);
    }

    @Override
    public void readFields(DataInput dataInput) throws IOException {
        this.str = dataInput.readUTF();
        this.time = dataInput.readInt();
    }
/*
        先按str从小到大排序
            在str排序的基础上，按时间的从小到大排序
 */
    @Override
    public int compareTo(StrTimeWritable o) {
        if(o.str.equals(this.str)){
            if(o.time==this.time){
                return 0;
            }else{
                return this.time-o.time;
            }
        }else{
            return this.str.compareTo(o.str);
        }
    }
}

分区类（作用：使相同组的数据在同一个Reduce下）：

package com.xxx.xxx.xxx.xxx.usepartition.getrecentnewmileage;

import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.lib.partition.HashPartitioner;

import java.util.HashMap;

/**
 * 相同的str末3位放在一个partition下
 * 在reduce过程中，相同的str会在同一个reduce下
 */
public class strpartition extends HashPartitioner<StrTimeWritable,Text> {

    /*
    * 1)numPartitions其实我们可以设置,在job.setNumReduceTasks(n)设置。
    * 2)如果我们job.setNumReduceTasks(5),那么这里的numPartitions=5,
    *   那么默认的HashPartitioner的机制就是用key的hashcode%numPartitions
    *   来决定分区属于哪个分区，所以分区数量就等于我们设置的reduce数量5个。
    */
    @Override
    public int getPartition(StrTimeWritable key,Text value , int numReduceTasks) {
        //srt : adf1efdadfa 047701
        //以str的最后3位 为分区依据
        //大写母、或者数字

        String strFinalTwoCharStr =key.getStr();//以整个str 作为分区
        return (strFinalTwoCharStr.hashCode() & Integer.MAX_VALUE) % numReduceTasks;
        //Integer hash = numMap.get(key.toString().substring(0, 1));
        //将没有匹配到的数据放入3号分区
        //return hash==null?3:hash;
    }
}

主MapReduce和Main函数代码：

package com.xxx.xxx.xxx.xxx.usepartition.five_min_qu_to_hbase;
/**
 */

import com.xxx.Util;
import com.xxx.xxx.xxx.xxx.usepartition.getrecentnewmileage.StrTimeWritable;
import com.xxx.xxx.xxx.xxx.usepartition.getrecentnewmileage.strpartition;
import org.apache.hadoop.hbase.mapred.TableOutputFormat;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.hbase.*;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.mapreduce.KeyValueSortReducer;
import org.apache.hadoop.hbase.mapreduce.LoadIncrementalHFiles;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.hadoop.hbase.io.ImmutableBytesWritable;
import org.apache.hadoop.hbase.mapreduce.HFileOutputFormat2;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.orc.mapred.OrcStruct;
import org.apache.orc.mapreduce.OrcInputFormat;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.*;
/**
 * 2019/11/25测试通过
 * HFileOutputFormat2.configureIncrementalLoadMap（推荐方式）
 * 最新的宜采用版本
 */
public class TwoMRFiveMinQuV3 {
    public static class HiveOrcToCellKVMapper extends
            Mapper<NullWritable, OrcStruct, StrTimeWritable, Text>{

        @Override
        public void map(NullWritable key, OrcStruct value, Context context)
                throws IOException, InterruptedException {
            if (value != null && value.getFieldValue(0) != null
                    && value.getFieldValue(1) != null
                    && value.getFieldValue(2) != null
                    && value.getFieldValue(5) != null) {
                String str = value.getFieldValue(0).toString().toUpperCase();
                String func = value.getFieldValue(1).toString();
                int time = Integer.parseInt(value.getFieldValue(2).toString());
                String data = value.getFieldValue(5).toString().toUpperCase();
                int k_time = time;
                if (time % (5 * 60) != 0) {
                    //为5分钟的倍数，则不变；否则，向上取五的倍数的整数
                    // 例如：2019/11/09 13:30:01 我们所保留的时间取2019/11/09 13:35:00
                    //       2019/11/09 13:34:37 我们所保留的时间取2019/11/09 13:35:00
                    //       2019/11/09 13:35:00 我们所保留的时间取2019/11/09 13:35:00
                    //          println(format.format(time*1000L))
                    //          println(format.format(((time / (5 * 60)) * 5 * 60 + 5 * 60) * 1000L))
                    k_time = (time / (5 * 60)) * 5 * 60 + 5 * 60;
                }
                StrTimeWritable strTimeWritable = new StrTimeWritable(str, k_time);
                context.write(strTimeWritable,new Text(func+"\t"+time+"\t"+data));
            }
        }
    }
    public static class CellKVCompactionReducer extends
            Reducer<StrTimeWritable, Text, Text,Text> {
        String checkSubQuID = "";

        @Override
        public void setup(Context context) throws IOException {
            checkSubQuID = context.getConfiguration().get("checkSubQuID");
        }
        @Override
        public void reduce(StrTimeWritable key, Iterable<Text> values,Context context)
                throws IOException, InterruptedException {
            String str = key.getStr();
            int k_time = key.getTime();
            List<ReduceValueForSort> textList = new LinkedList<>();
            for(Text val: values){//func+"\t"+time+"\t"+data
                if (!"".equals(val.toString())) {
                    String[] temp_str = val.toString().split("\t");
                    textList.add(new ReduceValueForSort(temp_str[0],Integer.parseInt(temp_str[1]),temp_str[2]));
                }
            }
            textList.sort(Comparator.comparingInt(ReduceValueForSort::getTime));//按时间排序

            String[] subQuIDs = checkSubQuID.split("\t");
            List<String> subQuIDList = new LinkedList<>();
            for (String a : subQuIDs) subQuIDList.add(a);
            Map<String, String> datas_Map = new HashMap();
            for(ReduceValueForSort rvfs : textList) {
                String func = rvfs.func;
                int time = rvfs.time;
                String data =rvfs.data;
                if (func.equals("007")) {
                    for (int index = 0; (index * 16) < data.length(); index++) {
                        String tempQuData = data.substring(index * 16, index * 16 + 16);
                        String re_a = tempQuData;
                        if (index == 0) {
                            re_a = "00000000" + re_a;
                        }
                        if (index == 1) {
                            re_a = "00000001" + re_a;
                        }
                        if (index == 2) {
                            re_a = "00000002" + re_a;
                        }
                        if (index == 3) {
                            re_a = "00000003" + re_a;
                        }
                        if (index == 4) {
                            re_a = "00000004" + re_a;
                        }
                        if (index == 5) {
                            re_a = "00000005" + re_a;
                        }
                        if (index == 6) {
                            re_a = "00000006" + re_a;
                        }
                        if (index == 7) {
                            re_a = "00000007" + re_a;
                        }
                        if (index == 8) {
                            re_a = "00000008" + re_a;
                        }
                        if (index == 9) {
                            re_a = "00000009" + re_a;
                        }
                        if (index == 10) {
                            re_a = "00000010" + re_a;
                        }
                        if (index == 11) {
                            re_a = "00000011" + re_a;
                        }
                        if (index == 12) {
                            re_a = "00000012" + re_a;
                        }
                        if (index == 13) {
                            re_a = "00000013" + re_a;
                        }
                        if (index == 14) {
                            re_a = "00000014" + re_a;
                        }
                        if (index == 15) {
                            re_a = "00000015" + re_a;
                        }
                        if (index == 16) {
                            re_a = "00000016" + re_a;
                        }
                        if (index == 17) {
                            re_a = "00000017" + re_a;
                        }
                        if (index == 18) {
                            re_a = "00000018" + re_a;
                        }
                        if (index == 19) {
                            re_a = "00000019" + re_a;
                        }
                        if (index == 20) {
                            re_a = "00000020" + re_a;
                        }
                        if (index == 21) {
                            re_a = "00000021" + re_a;
                        }
                        if (index == 22) {
                            re_a = "00000022" + re_a;
                        }
                        if (index == 23) {
                            re_a = "00000023" + re_a;
                        }
                        if (index == 24) {
                            re_a = "00000024" + re_a;
                        }
                        if (index == 25) {
                            re_a = "00000025" + re_a;
                        }
                        if (index == 26) {
                            re_a = "00000026" + re_a;
                        }
                        if (index == 27) {
                            re_a = "00000027" + re_a;
                        }
                        if (index == 28) {
                            re_a = "00000028" + re_a;
                        }
                        if (index == 29) {
                            re_a = "00000029" + re_a;
                        }
                        if (index == 30) {
                            re_a = "00000030" + re_a;
                        }
                        if (index == 31) {
                            re_a = "00000031" + re_a;
                        }
                        if (index == 32) {
                            re_a = "00000032" + re_a;
                        }
//          if(index > 32)  {re_a = "00000000"+ re_a} //Default
                        if (index <= 32) {
                            if (subQuIDList.contains(re_a.substring(0, 8))) {
                                datas_Map.put(re_a.substring(0, 10), re_a.substring(8));
                            } else {
                                datas_Map.put(re_a.substring(0, 8), re_a.substring(8));
                            }
                        }
                    }
                } else {
                    for (int i = 0; i < data.length(); i = i + 24) {
                        String temp_qu_data = data.substring(i, i + 24);
                        if (subQuIDList.contains(temp_qu_data.substring(0, 8))) {
                            datas_Map.put(temp_qu_data.substring(0, 10), temp_qu_data.substring(8));
                        } else {
                            datas_Map.put(temp_qu_data.substring(0, 8), temp_qu_data.substring(8));
                        }
                    }
                }
            }
            String rowKey = str.substring(11) + str.substring(0, 11) + "_" + (Integer.MAX_VALUE - k_time);
            Iterator iterator = datas_Map.keySet().iterator();
            StringBuffer stringBuffer = new StringBuffer();
            while (iterator.hasNext()){
                String qualifier = (String) iterator.next();
                String qu_v = datas_Map.get(qualifier);
                stringBuffer.append(qualifier+":"+qu_v+"\t");
            }
            context.write(new Text(rowKey), new Text(stringBuffer.toString()));
        }
    }
    public static class HFileMapper2 extends
            Mapper<Object, Text, ImmutableBytesWritable, KeyValue> {
        public static final byte[] CF = Bytes.toBytes("common");

        @Override
        public void map(Object key, Text value, Context context)
                throws IOException, InterruptedException {
            //输入文本内容：str.substring(11) + str.substring(0, 11) + "_" + (Integer.MAX_VALUE - k_time)+"\t"+
            //qualifier+":"+qu_v+"\t"+qualifier1+":"+qu_v1+"\t"...
            String[] values = value.toString().split("\t");
            String rowKey = values[0];
            for(int i=1;i< values.length;i++){
                if(null != values[i]) {
                    KeyValue keyValue = new KeyValue(Bytes.toBytes(rowKey),
                            CF,
                            Bytes.toBytes(values[i].split(":")[0]),
                            (Integer.MAX_VALUE - Integer.parseInt(rowKey.split("_")[1])) * 1000L,
                            Bytes.toBytes(values[i].split(":")[1]));
                    context.write(new ImmutableBytesWritable(Bytes.toBytes(rowKey)), keyValue);
                }
            }
        }
    }
    public static void main(String args[]) throws Exception {
//        System.out.println("设置HADOOP_USER_NAME用户");
//        System.setProperty("HADOOP_USER_NAME","hdfs");//仅对写HFile load到HBase中
//        System.setProperty("HADOOP_USER_NAME", "hadoop");
        String tableName = args[0];
        String startYMD = args[1];
        String stopYMD = args[2];
        String functionHDFSPath = args[3];//需要处理的功能号HDFS文件目录
        String subQuIDHDFSPath = args[4];
        String jobOutputHDFSPath = args[5];//预处理输出目录
        String jobOutputHDFSPath2 = args[6];//输出目录
        //HBase配置
        //1.获得配置文件对象
        Configuration conf = HBaseConfiguration.create();
        conf.set(TableOutputFormat.OUTPUT_TABLE,tableName);
        conf.set("hbase.mapreduce.bulkload.max.hfiles.perRegion.perFamily", "400");
        conf.set("orc.mapred.output.schema", "struct<str:String,func:int,time:int,type:int,grp:int,datas:String>");
//        mrConf.set("dfs.permissions","true");
        conf.set("mapreduce.map.memory.mb", "3072");
        conf.set("mapreduce.reduce.memory.mb", "4096");
        conf.set("yarn.nodemanager.resource.memory-mb", "8192");
        conf.set("yarn.nodemanager.vmem-pmem-ratio", "5");//2.1
        conf.set("mapreduce.input.fileinputformat.input.dir.recursive", "true");
        conf.set("io.serializations", "org.apache.hadoop.io.serializer.JavaSerialization," +
                "org.apache.hadoop.io.serializer.WritableSerialization," +
                "org.apache.hadoop.hbase.mapreduce.KeyValueSerialization," +
                "org.apache.hadoop.hbase.mapreduce.MutationSerialization," +
                "org.apache.hadoop.hbase.mapreduce.ResultSerialization" );
        String sub_QuIDs  = getSubQuIDAll(subQuIDHDFSPath, conf);
        System.out.println(sub_CQuDs);
        conf.set("checkSubQuID", sub_QuIDs);
        Job job1 = Job.getInstance(conf, "FivMinQuMR_" + startYMD + "_" + stopYMD);
        job1.setJarByClass(FiveMinQuMRT.class);
        job1.setMapperClass(HiveOrcToCellKVMapper.class);
        job1.setReducerClass(CellKVCompactionReducer.class);
        job1.setPartitionerClass(strpartition.class);
        job1.setMapOutputKeyClass(StrTimeWritable.class);
        job1.setNumReduceTasks(200);
        job1.setInputFormatClass(OrcInputFormat.class);
        //设置输入的orc文件
        List<String> DateList = new LinkedList<>();
        if (startYMD.equals(stopYMD)) {
            DateList.add(startYMD);
        } else {
            int daysCount = Util.getDaysFromCalendar(startYMD, stopYMD) + 2;
            DateList = Util.getDates(startYMD, daysCount);
        }
        List<Integer> FunctAll = getFunctAll(functionHDFSPath, conf);
        for (Integer temp : FunctAll) {//测试，输入的FunctAll
            System.out.println(temp);
        }
        for (String dataDates : DateList) {
            String year = dataDates.substring(0, 4);//年
            String month = dataDates.substring(4, 6);//月
            String day = dataDates.substring(6);//日
            for (Integer function : FunctAll) {
                FileSystem fileSystem = FileSystem.get(conf);
                Path inputPath1 = new Path("/user/xxx/xxx/xxx/funct=" + function + "/years=" + year + "/months=" + month + "/days=" + day + "/");
                boolean result = fileSystem.isDirectory(inputPath1);
                if (result == true)
                    FileInputFormat.addInputPath(job1, inputPath1);
            }
        }
        //第一个普通的 MR job输出到HDFS
        Path outputPath = new Path(jobOutputHDFSPath);
        FileOutputFormat.setOutputPath(job1, outputPath);
        outputPath.getFileSystem(conf).delete(outputPath, true);
        job1.waitForCompletion(true);
        if (job1.isSuccessful()) {//导入数据
            Job job2 = Job.getInstance(conf, "FivMinQuMR_" + startYMD + "_" + stopYMD);
            job2.setJarByClass(FiveMinQuMRT.class);
            job2.setMapperClass(HFileMapper2.class);
            job2.setReducerClass(KeyValueSortReducer.class);
            job2.setOutputKeyClass(ImmutableBytesWritable.class);
            job2.setOutputValueClass(KeyValue.class);
            job2.setNumReduceTasks(100);
            Path outputPath2 = new Path(jobOutputHDFSPath2);
            FileInputFormat.addInputPath(job2, outputPath);
            FileOutputFormat.setOutputPath(job2, outputPath2);
            outputPath.getFileSystem(conf).delete(outputPath2, true);

//        2.建立连接
            Connection connection = ConnectionFactory.createConnection(conf);
            //3.获得会话
            Admin admin = connection.getAdmin();
            TableName tableNames = TableName.valueOf(tableName);
            Table table = connection.getTable(tableNames);
            //设置输出的文件格式
//        hadoop中的job.setOutputKeyClass(theClass)与job.setOutputValueClass(theClass)，
//        但是有的程序处理以上两个外还有job.setMapOutputKeyClass(theClass）与job.setMapOutputValueClass(Text.class)，
//        一直没弄懂是怎么回事，网上查了下，原来当mapper与reducer的输出类型一致时可以用job.setOutputKeyClass(theClass)
//        与job.setOutputValueClass(theClass)这两个进行配置就行，但是当mapper用于reducer两个的输出类型不一致的时候就需
//        要分别进行配置了。
//        HFileOutputFormat2.configureIncrementalLoad源码中有设置job.setOutputKeyClass(theClass)job.setOutputValueClass(theClass)
//        分别为ImmutableBytesWritable 、Put（KeyValue）
//        这就导致了要么设置Map 和 Reduce 的输出都为ImmutableBytesWritable 、Put（KeyValue）
//        要么只有一个Map 并且设置输出为ImmutableBytesWritable 、Put（KeyValue）
//        HFileOutputFormat2.configureIncrementalLoad(job, table, connection.getRegionLocator(tableNames));//执行代码的用户是hdfs用户生成Hfile的临时目录的拥有者也是hdfs 但是在执行BulkLoad 操作用户却是Hbase用户，真是叫人头大  //这个会导致，没有权限：Failing Oozie Launcher, Main class [org.apache.oozie.action.hadoop.JavaMain], main() threw exception, org.apache.hadoop.security.AccessControlException: Permission denied: user=wang.nengjie, access=EXECUTE, inode="/user/yarn":yarn:supergroup:drwx------
//        HFileOutputFormat.configureIncrementalLoad(job,new HTable(hbConf,tableName));
            HFileOutputFormat2.configureIncrementalLoadMap(job2, table);
            job2.waitForCompletion(true);
            if (job2.isSuccessful()) {//导入数据
                try {
                    LoadIncrementalHFiles loadFiles = new LoadIncrementalHFiles(conf);
                    loadFiles.doBulkLoad(outputPath2, admin, table, connection.getRegionLocator(tableNames));
                    System.out.println("Bulk Load Completed..");
                } catch (Exception exception) {
                    exception.printStackTrace();
                }
            }
            System.exit(job2.waitForCompletion(true) ? 0 : 1);
        }
    }

    public static void doBulkLoad(String pathToHFile, String tableName) {
        try {
            Configuration configuration = new Configuration();
            HConnection connection = HConnectionManager.createConnection(configuration);
            HBaseConfiguration.addHbaseResources(configuration);
            LoadIncrementalHFiles loadFiles = new LoadIncrementalHFiles(configuration);
            loadFiles.doBulkLoad(new Path(pathToHFile), (HTable) connection.getTable(tableName));
            System.out.println("Bulk Load Completed..");
        } catch (Exception exception) {
            exception.printStackTrace();
        }

    }

    public static List<Integer> getFunctAll(String functionSrcPath, Configuration conf) {
        List<Integer> list = new LinkedList<>();
        try {
            Path path = new Path(functionSrcPath);//HDFS路径Path
            FileSystem fs = FileSystem.get(conf);
//            List<String> files = new ArrayList<String>();
            if (fs.exists(path)) {
//                        for (FileStatus status : fs.listStatus(path)) {//file name
//                            files.add(status.getPath().toString());
//                        }
                InputStream in = fs.open(path);
                BufferedReader buff = new BufferedReader(new InputStreamReader(in));
//                in.close();//不可加该代码  不然出错：System.exit(job.waitForCompletion(true) ? 0 : 1);
                String str = null;
                while ((str = buff.readLine()) != null) {//一行一个
                    if (str.matches("[0-9]+")) {
                        list.add(Integer.parseInt(str));
                    }
                }
            } else {
                throw new IOException("function file not exists!");
            }
//            fs.close();
        } catch (IOException e) {
        } catch (Exception e) {
        }
        return list;
    }

    public static String getSubQuIDAll(String functionSrcPath, Configuration conf) {
        String str = "";
        try {
            Path path = new Path(functionSrcPath);//HDFS路径Path
            FileSystem fs = FileSystem.get(conf);
//            List<String> files = new ArrayList<String>();
            if (fs.exists(path)) {
//                        for (FileStatus status : fs.listStatus(path)) {//file name
//                            files.add(status.getPath().toString());
//                        }
                InputStream in = fs.open(path);
                BufferedReader buff = new BufferedReader(new InputStreamReader(in));
//                in.close();//不可加该代码  不然出错：System.exit(job.waitForCompletion(true) ? 0 : 1);
                str = buff.readLine();
//                while ((str = buff.readLine()) != null) {//一行一个功能号
//                }

            } else {
                throw new IOException("function file not exists!");
            }
//            fs.close();
        } catch (IOException e) {
        } catch (Exception e) {
        }
        return str;
    }
}

最有一个为为了List对象排序的一个代码：

package com.xxx.xxx.xxx.xxx.usepartition.five_min_qu_to_hbase;

public class ReduceValueForSort {
    String func;
    int time;
    String data;

    public ReduceValueForSort(String func, int time, String data) {
        this.func = func;
        this.time = time;
        this.data = data;
    }

    public int getTime(){
        return  time;
    }
}

最终，我们运行几个T的数据时间为5个小时。HBase长时间处于SplitRegion得到改善。但是因为我生成的HFile文件为100个，每个未压缩状态下几个G，总共500多G，所以还存在HFile合并的状态，即Compacte状态。因为我们设置的HFile最大为50G所以估计在合并完成之后，还有少量的Split状态。

拉普达男孩
关注
专栏目录
Hadoop基础操作--管理多个MapReduce任务
m0_58945994的博客
10-21 1114
一、查询MapReduce任务。 例：调用Hadoop的示例程序包，采用Quasi-Monte Carlo算法来估算PI的值。命令如下： hadoop jar /usr/local/hadoop-2.6.4/share/hadoop/mapreduce/hadoop-mapreduce-examples-2.6.4.jar pi 10 100 其中，命令后面的两个参数代表Map数量与每个Map的测算次数，数值越大，结果精准度越高。 在运行过程中，打开集群的资源管理器的监控服务主界面（http://m
总结系列文章3 查询 MapReduce 任务
m0_60658863的博客
11-02 908
（1）启动集群 （2）查看在线节点数 调用Hadoop的示例jar包 提交任务 终断任务 （1）提交任务 （2）中断任务
Hadoop 里MapReduce里 实现多个job任务 包含（迭代式、依赖式、链式）
yhblog的博客
11-26 851
一、迭代式，所谓的迭代式，下一个执行的Job任务以上一个Job的输出作为输入，最终得到想要的结果。 这里我只写关键的代码了 Job job = new Job(new Configuration()); //设置job输入路径 FileInputFormat.setInputPaths(job,inputPath); //设置job输出的路径 FileOutputFormat.setOutput...
多个MapReduce任务实现任务间相互依赖
zl520878的博客
09-16 626
工作过程工遇到有些情况，需要多个mapreduce程序相互依赖执行，使用ControlledJob类可以轻松处理多个JOB之间按照顺序执行。   输入文件为2个，t1.txt和t2.txt，内容如下： t1: abacdab   t2: caedbaecc   执行如下命令：   hadoop jar /home/sospdm/morejobs.jar morejobs....
MapReduce-多个Mapper
weixin_30266829的博客
08-25 571
MapReduce的多输入、多mapper 虽然一个MapReduce作业的输入可能包含多个输入文件（由文件glob、过滤器和路径组成），但所有文件都由同一个InputFormat和同一个Mapper来解释。然而，数据格式往往会随时间而演变，所以必须写自己的mapper来处理应用中的遗留数据格式问题。或者，有些数据源会提供相同的数据，但是格式不同。这些问题可以用MultipleInputs类来妥...
MapReduce之多输入
小方块的博客
07-07 294
MapReduce之多输入 0.概念 说明：多输入指的是数据源有多种格式的数据，比如在一个目录下有文本类型的和SequenceFile二进制格式的，针对这种场景，需要使用MapReduce来分析数据。 要求：改写wordcount程序的输入数据源，实现单词统计。 思路： 1、有多少种数据格式，就需要编写与之对应的mapper即可 2、需要使用MultipleInputs类来实现 序列化文件 链接：https://pan.baidu.com/s/1RWN57bVDnUPEQwu-YsfXHw 提取码：n1
用于期限约束的MapReduce任务调度算法
02-24
1. MapReduce任务调度的背景与挑战：在处理大规模数据时，MapReduce模型需要将任务高效地分配到多个计算节点上。传统调度算法可能无法考虑任务类型（Map与Reduce任务的区别）和集群的异质性（即节点性能差异），导致...
利用采样器实现mapreduce任务输出全排序
12-02
利用采样器实现mapreduce任务输出全排序大数据-MapReduce
window10下的eclipse用java连接hadoop执行mapreduce任务-附件资源
03-02
window10下的eclipse用java连接hadoop执行mapreduce任务-附件资源
4，wordcount 多MapReduce任务的串联
wonderboyLU的博客
07-16 602
一，combiner实验: Map阶段结束后，产生的键值对的value全为1，为了减少map将键值对传到节点上时用过多的时间和内存，减少reduce端聚合的次数，在map之后reduce之前，先将每个map任务产生的相同key值的value进行一次合并。由于在wordcount中combiner操作与reduce操作是一样的，所以Mycombiner类代码内容与reducer一样。 在编写完combiner类之后，要在主类下进行设置。如下图： 其他类不变。 二，多mapRedu...
【MapReduce】Mapreduce基础知识整理 (五) 多Job串联、共同好友案例
人生所向，皆是美好
12-18 303
文章目录前言多job串联案例求共同好友 前言 一个任务中包含多个mapreduce任务（job）,多个job之间有相互的依赖关系的 需要进行多job串联 操作步骤: //将我们的普通的job转成Controlledjob //job.getCon/getLong... 都是来自job.xml ControlledJob cjob1=new ControlledJob(job1.getConf...
结合案例讲解MapReduce重要知识点 --------- 多个job之间有序执行
Z_Data的博客
11-11 685
每一个MapReduce程序都封装成一个job，而多个job之间呢？后一个job输入的数据，就是前一个job的输出的数据。 本节就是演示这种场景： 顺序执行 两个job执行是有先后顺序的 import java.io.IOException; import org.apache.hadoop.conf.Configuration; import org.apache.hadoo...
mapper排序_完成功能MapReduce驱动两个job、二次排序、求Url的topN
weixin_39620578的博客
12-04 109
“脑子里想法，总是想去代码实现”//用mapreduce来实现下面需求？//现在有10个文件夹,每个文件夹都有1000000个url.现在让你找出top1000000url。//方法一：// 运用2个job，第一个job直接用filesystem读取10个文件夹作为map输入，url做key，reduce计算url的sum，// 下一个job map用url作...
【MapReduce】数据去重、多表查询、倒排索引、单元测试等案例编程
lys_828的博客
07-22 842
数据去重、多表查询、倒排索引、单元测试等案例编程1 数据去重2 多表查询3 倒排索引4 单元测试 1 数据去重 相当于实现SQL里面的distinct的功能。废话不说多，直接进行代码编程，创建一个demo.distinct的package，然后进行框架的搭建（框架里面包含Mapper、Reducer和执行的主程序三个文件），如下 首先开发Mapper程序，具体的代码如下（基本上之前都见过了，没啥区别） package demo.distinct; import java.io.IOException;
MapReduce处理系统
crazy_scott的博客
10-01 658
MapReduce：a Batch Processing System MPI MPI是一个信息传递应用程序接口，包括协议和和语义说明。 是为了处理进程间通讯的协议。 问题： 在MapReduce出现之前，已经有像MPI这样非常成熟的并行计算框架了，那么为什么Google还需要MapReduce？ 这是因为，传统并行计算框架基本上都还是在单机上，为了保证不易宕机，一般都选择昂贵的刀片服务器...
对HBase数据库的操纵（MapReduce）
https://gitcode.net/liuyuan185442111
07-13 696
操纵HBase数据库有如下几种方式：其一是使用hbase shell，其二是使用Java API，其三是通过MapReduce。另外HBase还提供了Avro，REST和Thrift接口，不过一般用的较少。 在《HBase操作》和[《如何用MapReduce程序操作》]hbase(http://blog.csdn.net/liuyuan185442111/article/details/45306
MapReduce知识点
qq_33439938的博客
09-13 1503
MapReduce 知识点结构图 本文初衷是为了学习归纳，若有错误，请指出。 修改记录 时间 内容 2020年9月13日 第一次发布 一、MapReduce概述 1.1 MapReduce定义 MapReduce是采用一种分而治之的思想设计出来的分布式计算框架 如一项复杂的计算任务，单台服务器无法胜任时，可将此大任务切分成一个个小的任务，分别交给不同的服务器上并行执行，最终再汇总每个小任务的结果 MapReduce由两个阶段组成：Map阶段（把一个任务切分成多个任务），R
关于Mapreduce中多任务串联执行的认识
zhigang1007的博客
10-25 1697
最近加深了下Mapreduce的分布计算框架的理解，处理一些业务逻辑时，发现需要多个mapreduce程序才能完成。为了降低代码执行的繁琐度，将多个main文件合成一个，研究了下多任务的串联执行。下面就开始说说我的认识吧！ 业务逻辑是比较普遍的求共同好友的测试。一般而言，根据业务逻辑，需要编写两个mapreduce程序，分别放在两个java文件中，先后执行才能获取最终的结果。下面是我将两
mapreduce任务调度
最新发布
06-01
MapReduce 是一种分布式...当一个作业被提交到 MapReduce 系统时，JobTracker 会将其分解成多个任务，并将这些任务分配给多个 TaskTracker 执行。JobTracker 还会监控整个作业的执行情况，并在出现故障时进行容错处理。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值