MapReduce之Shuffle机制

已于 2022-03-31 14:36:34 修改
阅读量2.3k 收藏 3
点赞数
分类专栏： Hadoop 大数据 文章标签： hadoop mapreduce
于 2022-03-31 14:33:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43461159/article/details/123871436
版权

Shuffle机制

参考尚硅谷大数据相关资料

Map方法之后，Reduce方法之前的数据处理过程称之为Shuffle。

shuffle机制

1 Partition分区

1、Partitioner是Hadoop的分区器对象：负责给Map阶段输出数据选择分区的功能

  • 默认实现HashPartitioner类 。按照 输出的key的hashCode值 和 ReduceTask的数量 进行取余操作会得到一个数字，这个数字就只当前<k,v>所属分区的编号，分区编号在Job提交的时候就已经根据指定ReduceTask的数量定义好了。

2、Hadoop默认的分区规则源码解析

  • 定位MapTask的map方法中 context.write(outk, outv);

  • 跟到write(outk, outv)中 进入到 ChainMapContextImpl类的实现中

    public void write(KEYOUT key, VALUEOUT value) throws IOException,
	InterruptedException {
		output.write(key, value);
	}

  • 跟到 output.write(key, value) 内部 NewOutputCollector

public void write(K key, V value) throws IOException, InterruptedException {
				collector.collect(key, value,
								partitioner.getPartition(key, value, partitions));
			}

  • 重点理解 partitioner.getPartition(key, value, partitions)；

  • 跟进默认的分区规则实现 HashPartitioner类

    public int getPartition(K key, V value,
	int numReduceTasks) {
	// 根据当前的key的hashCode值和ReduceTask的数量进行取余操作
	// 获取到的值就是当前kv所属的分区编号。
	return (key.hashCode() & Integer.MAX_VALUE) % numReduceTasks;
}

3、自定义分区器对象

  • 自定一个分区器类，继承Hadoop提供的Partitioner类，实现getPartition() 方法，在方法中编写自己的业务逻辑，最终给当前kv返回所属的分区编号。

  • 分区器使用时注意事项

    • 当ReduceTask的数量设置 > 实际用到的分区数 此时会生成空的分区文件

    • 当ReduceTask的数量设置 < 实际用到的分区数 此时会报错

    • 当ReduceTask的数量设置 = 1 结果文件会输出到一个文件中，

      由以下源码可以论证：

    // 获取当前ReduceTask的数量
partitions = jobContext.getNumReduceTasks();
	// 判断ReduceTask的数量 是否大于1，找指定分区器对象
	if (partitions > 1) {
		partitioner = (org.apache.hadoop.mapreduce.Partitioner<K,V>)
		ReflectionUtils.newInstance(jobContext.getPartitionerClass(), job);
		} else {
		// 执行默认的分区规则，最终返回一个唯一的0号分区
		partitioner = new org.apache.hadoop.mapreduce.Partitioner<K,V>() {
			@Override
			public int getPartition(K key, V value, int numPartitions) {
			return partitions - 1;
			}
		};
	}

  • 分区编号生成的规则：根据指定的ReduceTask的数量 从0开始，依次累加。

Partition分区案例实操

1、问题引出

要求将统计结果按照条件输出到不同文件中（分区）。比如：将统计结果按照手机归属地不同省份输出到不同文件中（分区）

2、默认Partitioner分区

public class HashPartitioner<K, V> extends Partitioner<K, V> {
  public int getPartition(K key, V value, int numReduceTasks) {
    return (key.hashCode() & Integer.MAX_VALUE) % numReduceTasks;
  }
}

默认分区是根据key的hashCode对ReduceTasks个数取模得到的。用户没法控制哪个key存储到哪个分区。

3、自定义Partitioner步骤

（1）自定义类继承Partitioner，重写getPartition()方法

public class CustomPartitioner extends Partitioner<Text, FlowBean> {
 	@Override
	public int getPartition(Text key, FlowBean value, int numPartitions) {
          // 控制分区代码逻辑
    … …
		return partition;
	}
}

（2）在Job驱动中，设置自定义Partitioner

job.setPartitionerClass(CustomPartitioner.class);

（3）自定义Partition后，要根据自定义Partitioner的逻辑设置相应数量的ReduceTask

job.setNumReduceTasks(5);

4、分区总结

（1）如果ReduceTask的数量> getPartition的结果数，则会多产生几个空的输出文件part-r-000xx；

（2）如果1<ReduceTask的数量<getPartition的结果数，则有一部分分区数据无处安放，会Exception；

（3）如果ReduceTask的数量=1，则不管MapTask端输出多少个分区文件，最终结果都交给这一个ReduceTask，最终也就只会产生一个结果文件 part-r-00000；

（4）分区号必须从零开始，逐一累加。

5、案例分析

例如：假设自定义分区数为5，则

（1）job.setNumReduceTasks(1); 会正常运行，只不过会产生一个输出文件

（2）job.setNumReduceTasks(2); 会报错

（3）job.setNumReduceTasks(6); 大于5，程序会正常运行，会产生空文件

代码实现

public class PhonePartitioner extends Partitioner<Text,FlowBean> {

    /**
     * 定义当前kv所属分区规则
     * @param text
     * @param flowBean
     * @param numPartitions
     * @return
     * 136 --> 0
     * 137 --> 1
     * 138 --> 2
     * 139 --> 3
     * 其他 --> 4
     */
    @Override
    public int getPartition(Text text, FlowBean flowBean, int numPartitions) {
        int phonePartitions  = 0;
        String phoneNum = text.toString();
        if(phoneNum.startsWith("136")){
            phonePartitions = 0;
        } else if (phoneNum.startsWith("137")) {
            phonePartitions = 1;
        } else if (phoneNum.startsWith("138")) {
            phonePartitions = 2;
        } else if (phoneNum.startsWith("139")) {
            phonePartitions = 3;
        } else {
            phonePartitions = 4;
        }
        return phonePartitions;
    }
}

在Driver中设置reduceTask数量和自定义分区对象

//指定ReduceTask数量为5
job.setNumReduceTasks(5);
//指定自定义分区对象实现
job.setPartitionerClass(PhonePartitioner.class);
2 WritableComparable排序

1、排序概述

排序是MapReduce框架中最重要的操作之一。

MapTask和ReduceTask均会对数据按照key进行排序。该操作属于Hadoop的默认行为。任何应用程序中的数据均会被排序，而不管逻辑上是否需要。

默认排序是按照字典顺序排序，且实现该排序的方法是快速排序。

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

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

2、排序分类

（1）部分排序

MapReduce根据输入记录的键对数据集排序。保证输出的每个文件内部有序。

（2）全排序

最终输出结果只有一个文件，且文件内部有序。实现方式是只设置一个ReduceTask。但该方法在处理大型文件时效率极低，因为一台机器处理所有文件，完全丧失了MapReduce所提供的并行架构。

（3）辅助排序：（GroupingComparator分组）

在Reduce端对key进行分组。应用于：在接收的key为bean对象时，想让一个或几个字段相同（全部字段比较不相同）的key进入到同一个reduce方法时，可以采用分组排序。

（4）二次排序

在自定义排序过程中，如果compareTo中的判断条件为两个即为二次排序。

3、Hadoop中实现比较排序

  1. Hadoop 中的实现排序比较的方式

    • 直接让参与比较的对象上实现WritableComparable 接口，并在该类中实现 compareTo方法，在compareTo中定义自己的比较规则。这种情况当运行的的时候Hadoop会帮助我们生成 比较器对象WritableComparator。
    • 自定一个比较器对象需要继承Hadoop提供的WritableComparator类，重写该类compare() 方法，在该方法中定义比较规则，注意在自定义的比较器对象中通过调用父类的super方法将自定义的比较器对象和要参与比较的对象进行关联。最后再Driver类中指定自定义的比较器对象。

  2. Hadoop中获取比较器对象的规则是什么？（通过源码解析分析…）

    • 定位到 MapTask 类中的init() 方法

      // 获取比较器对象
comparator = job.getOutputKeyComparator();

    • 定位 JobConf 类中 getOutputKeyComparator()

      // job提交的时候 获取当前MR程序输出数据key的比较器对象
public RawComparator getOutputKeyComparator() {
    Class<? extends RawComparator> theClass = getClass(
            JobContext.KEY_COMPARATOR, null, RawComparator.class);
    if (theClass != null){
        // 如果通过配置获取到指定的比较器对象的class 直接通过反射示例化
        return ReflectionUtils.newInstance(theClass, this);
    }

    // 如果通过配置没获取到指定的比较器对象，接着判断 
    // 当前参与比较的对象是否实现了WritableComparable接口
    return WritableComparator.get(getMapOutputKeyClass()
            .asSubclass(WritableComparable.class), this);
}

// get()方法就是实现获取比较器对象的逻辑  
public static WritableComparator get(
        Class<? extends WritableComparable> c, Configuration conf) {

    // 根据当前传入的class文件到 comparators的Map中获取比较器对象
    // 这种情况是 当前参与比较的对象的类型是Hadoop自身的数据类型
    WritableComparator comparator = comparators.get(c);

    if (comparator == null) {
        // 考虑到一些极端情况，可能发生GC垃圾回收，导致比较器没了
        // 为了万无一失 再次让类加载一遍
        forceInit(c);
        // 重新加载后再次获取
        comparator = comparators.get(c);
        // 此时还没获取到，那就说明当前参与比较的对象的不是Hadoop自身的数据类型
        if (comparator == null) {
            // Hadoop 会给当前参与比较的对象生成比较器对象
            comparator = new WritableComparator(c, conf, true);
        }
    }
    // Newly passed Configuration objects should be used.
    ReflectionUtils.setConf(comparator, conf);
    return comparator;
}

  3. Hadoop自身的数据类型是如何拥有比较器对象

  • 以Text为例：打开Text的源码

    1. 当前Text实现了WritableComparable接口

    2. 在该类中 定义了自己的比较器对象

      public static class Comparator extends WritableComparator {
		public Comparator() {
			super(Text.class);
		}

    3. 该类中还包含一个静态代码快

       static {
		// register this comparator
		WritableComparator.define(Text.class, new Comparator());
	}

    4. Text类它的比较器对象被管理到一个Map中，以当前类的class文件为key当前类的比价器对象为value

       public static void define(Class c, WritableComparator comparator) {
		comparators.put(c, comparator);
		}

4、排序案例

1）需求

根据序列化案例产生的结果再次对总流量进行倒序排序。

在这里插入图片描述

2）代码实现

​ 1、在FlowBean中实现WritableComparabe接口，重写compareTo方法

    /**
     * 自定义排序规则
     * 根据总流量
     * @param o
     * @return
     */
    @Override
    public int compareTo(FlowBean o) {
        return -this.getSumFlow().compareTo(o.getSumFlow());
    }

​ 2、编写Mapper类

package com.xu1an.mr.writableComparable;

import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;

import java.io.IOException;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: Xu1Aan
 * @Date: 2022/03/17/20:32
 * @Description:
 */
public class FlowMapper extends Mapper<LongWritable, Text, FlowBean, Text> {

    private Text outValue = new Text();
    private FlowBean outKey = new FlowBean();

    /**
     * 核心业务逻辑处理
     * @param key
     * @param value
     * @param context
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, FlowBean, Text>.Context context) throws IOException, InterruptedException {
        //获取当前行数据
        String line = value.toString();
        //切割数据
        String[] phoneData = line.split("\t");

        //当前数据： 7   13560436666  120.196.100.99  1116    954      200
        //获取输出数据的key(手机号)
        outValue.set(phoneData[1]);
        //获取输出数据的value
        int up = Integer.parseInt(phoneData[phoneData.length - 3]);
        int down = Integer.parseInt(phoneData[phoneData.length - 2]);
        outKey.setUpFlow(up);
        outKey.setDownFlow(down);
        outKey.setSumFlow(up+down);

        //将数据输出
        context.write(outKey,outValue);
    }
}

3、编写Reducer类

package com.xu1an.mr.writableComparable;

import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: Xu1Aan
 * @Date: 2022/03/17/20:32
 * @Description:
 */
public class FlowReduce extends Reducer<FlowBean, Text, Text, FlowBean> {

    private Text outKey = new Text();
    private FlowBean outValue = new FlowBean();

    /**
     * 核心业务逻辑处理
     * @param key
     * @param values
     * @param context
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void reduce(FlowBean key, Iterable<Text> values, Reducer<FlowBean, Text, Text, FlowBean>.Context context) throws IOException, InterruptedException {
        for (Text value : values) {
            context.write(value,key);
        }
    }
}

4、设置Driver

package com.xu1an.mr.writableComparable;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
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;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: Xu1Aan
 * @Date: 2022/03/17/20:32
 * @Description:
 */
public class FlowDriver {
    public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException {
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf);

        job.setJarByClass(FlowDriver.class);
        job.setMapperClass(FlowMapper.class);
        job.setReducerClass(FlowReduce.class);

        job.setMapOutputKeyClass(FlowBean.class);
        job.setMapOutputValueClass(Text.class);

        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(FlowBean.class);

        //设置自定义比较器对象
        job.setSortComparatorClass(FlowBeanComparator.class);
        
        //可将Partition分区应用到这里
        //设置ReduceTask的数量
        job.setNumReduceTasks(5);
        //指定自定义分区
        job.setPartitionerClass(PhonePartitioner.class);

        FileInputFormat.setInputPaths(job,new Path("E:\\learning\\04_java\\02_大数据资料\\00_hadoop\\资料\\07_测试数据\\phone_data"));
        FileOutputFormat.setOutputPath(job,new Path("E:\\learning\\04_java\\02_大数据资料\\00_hadoop\\out\\data_4"));

        job.waitForCompletion(true);
    }
}
3 Combiner合并

（1）Combiner是MR程序中Mapper和Reducer之外的一种组件。

（2）Combiner组件的父类就是Reducer。

（3）Combiner和Reducer的区别在于运行的位置

		Combiner是在每一个MapTask所在的节点运行;

​ Reducer是接收全局所有Mapper的输出结果；

（4）Combiner的意义就是对每一个MapTask的输出进行局部汇总，以减小网络传输量。

（5）Combiner能够应用的前提是不能影响最终的业务逻辑，而且，Combiner的输出kv应该跟Reducer的输入kv类型要对应起来。

Mapper
3 5 7 ->(3+5+7)/3=5 
2 6 ->(2+6)/2=4

Reducer
(3+5+7+2+6)/5=23/5  不等于  (5+4)/2=9/2

Combiner 流程的使用

  • Combiner的使用场景：总的来说，为了提升MR程序的运行效率，为了减轻ReduceTask的压力，另外减少IO的开销。
  • 使用Combiner
    • 自定一个Combiner类 继承Hadoop提供的Reducer
    • 在Job中指定自定义的Combiner类
  • Combiner不适用的场景：Reduce端处理的数据考虑到多个MapTask的数据的整体集时 就不能提前合并了。

3.3 OutputFormat数据输出

3.1 OutputFormat接口实现类

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

1. 概念：OutputFormat主要负责最终数据的写出

  • OutputFormat 类的体系结构

    • FileOutputFormat OutputFormat的子类（实现类): 对 checkOutputSpecs() 做了具体的实现(检查提交路径)
    • TextOutputFormat FileOutputFormat的子类: 对 getRecordWriter() 做了具体实现

  • OutputFormat的使用场景

    当我们对MR最终的结果有个性化制定的需求，就可以通过自定义OutputFormat来实现

  • 如何实现OutputFormat自定义：

① 自定一个 OutputFormat 类，继承Hadoop提供的OutputFormat，在该类中实现getRecordWriter() ,返回一个RecordWriter

② 自定义一个 RecordWriter 并且继承Hadoop提供的RecordWriter类，在该类中重写 write() 和 close() 在这些方法中完成自定义输出。

2．文本输出TextOutputFormat

​ 默认的输出格式是TextOutputFormat，它把每条记录写为文本行。它的键和值可以是任意类型，因为TextOutputFormat调用toString()方法把它们转换为字符串。

3．SequenceFileOutputFormat

​ 将SequenceFileOutputFormat输出作为后续 MapReduce任务的输入，这便是一种好的输出格式，因为它的格式紧凑，很容易被压缩。

4．自定义OutputFormat

​ 根据用户需求，自定义实现输出。

5．使用场景

​ 为了实现控制最终文件的输出路径和输出格式，可以自定义OutputFormat。

​ 例如：要在一个MapReduce程序中根据数据的不同输出两类结果到不同目录，这类灵活的输出需求可以通过自定义OutputFormat来实现。

6．自定义OutputFormat步骤

（1）自定义一个类继承FileOutputFormat。

（2）改写RecordWriter，具体改写输出数据的方法write()。

3.2自定义OutputFormat案例实操

1）需求分析

​ 过滤输入的log日志，包含xu1an的网站输出到e:/xu1an.log，不包含xu1an的网站输出到e:/other.log。

2）案例实操

（1）编写LogMapper类

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.IOException;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: Xu1Aan
 * @Date: 2022/03/22/16:01
 * @Description:
 */
public class LogMapper extends Mapper<LongWritable, Text, Text, NullWritable> {

    /**
     * 核心处理方法
     * @param key
     * @param value
     * @param context
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, NullWritable>.Context context) throws IOException, InterruptedException {
        //直接写出
        context.write(value, NullWritable.get());
    }
}

（2）编写LogReducer类

import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;

import java.io.IOException;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: Xu1Aan
 * @Date: 2022/03/22/16:02
 * @Description:
 */
public class LogReducer extends Reducer<Text, NullWritable,Text, NullWritable> {
    @Override
    protected void reduce(Text key, Iterable<NullWritable> values, Reducer<Text, NullWritable, Text, NullWritable>.Context context) throws IOException, InterruptedException {
        //遍历直接写出
        for (NullWritable value : values) {
            context.write(key,NullWritable.get());
        }
    }
}

（3）自定义一个OutputFormat类

import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.RecordWriter;
import org.apache.hadoop.mapreduce.TaskAttemptContext;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

import java.io.IOException;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: Xu1Aan
 * @Date: 2022/03/22/16:12
 * @Description:
 * 自定义的OutputFormat需要继承Hadoop提供的OutputFormat
 */
public class LogOutputFormat extends FileOutputFormat<Text, NullWritable>{

    @Override
    public RecordWriter<Text, NullWritable> getRecordWriter(TaskAttemptContext job) throws IOException, InterruptedException {
        LogRecordWriter logRecordWriter = new LogRecordWriter(job);
        return logRecordWriter;
    }
}

（4）编写LogRecordWriter类

package com.xu1an.mr.outputFormat;

import org.apache.hadoop.fs.FSDataOutputStream;
import org.apache.hadoop.fs.FileSystem;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IOUtils;
import org.apache.hadoop.io.NullWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.RecordWriter;
import org.apache.hadoop.mapreduce.TaskAttemptContext;

import java.io.IOException;


/**
 * Created with IntelliJ IDEA.
 *
 * @Author: Xu1Aan
 * @Date: 2022/03/22/16:16
 * @Description:
 */
public class LogRecordWriter extends RecordWriter<Text, NullWritable> {

    //定义输出路径
    private String xu1anPath = "E:\\learning\\04_java\\02_大数据资料\\00_hadoop\\out\\xu1an.txt";
    private String otherPath = "E:\\learning\\04_java\\02_大数据资料\\00_hadoop\\out\\other.txt";
    private FileSystem fs;
    private FSDataOutputStream xu1anOutputStream;
    private FSDataOutputStream otherOutputStream;


    public LogRecordWriter(TaskAttemptContext job) throws IOException {
        //获取Hadoop的文件系统对象
        fs = FileSystem. get(job.getConfiguration());
        //获取输出流
        xu1anOutputStream = fs.create(new Path(xu1anPath));
        //获取输出流
        otherOutputStream= fs.create(new Path(otherPath));
    }



    /**
     * 实现数据写出的逻辑
     * @param key
     * @param value
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    public void write(Text key, NullWritable value) throws IOException, InterruptedException {
        //获取当前输入数据
        String logData = key.toString();
        if (logData.contains("xu1an")){
            xu1anOutputStream.writeBytes(logData+"\n");
        } else {
            otherOutputStream.writeBytes(logData+"\n");
        }

    }

    /**
     * 关闭资源
     * @param context
     * @throws IOException
     * @throws InterruptedException
     */
    @Override
    public void close(TaskAttemptContext context) throws IOException, InterruptedException {
        IOUtils.closeStream(xu1anOutputStream);
        IOUtils.closeStream(otherOutputStream);
    }
}

（5）编写LogDriver类

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;

/**
 * Created with IntelliJ IDEA.
 *
 * @Author: Xu1Aan
 * @Date: 2022/03/22/16:02
 * @Description:
 */
public class LogDriver {

    public static void main(String[] args) throws IOException, InterruptedException, ClassNotFoundException {
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf);
        job.setJarByClass(LogDriver.class);
        job.setMapperClass(LogMapper.class);
        job.setReducerClass(LogReducer.class);

        job.setMapOutputKeyClass(Text.class);
        job.setMapOutputValueClass(NullWritable.class);

        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(NullWritable.class);

        FileInputFormat.setInputPaths(job,new Path("E:\\learning\\04_java\\02_大数据资料\\00_hadoop\\资料\\07_测试数据\\log"));
        FileOutputFormat.setOutputPath(job,new Path("E:\\learning\\04_java\\02_大数据资料\\00_hadoop\\out\\data5"));

        //指定OutputFormat类
        job.setOutputFormatClass(LogOutputFormat.class);

        job.waitForCompletion(true);

    }
}
- Xu1Aan！
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
mapreduce的shuffle
qq_27347421的博客
02-03 405
shuffle的环形缓冲区 map----shuffle过程—reduce 元数据：描述原始数据的数据 原始数据在缓冲区的位置 1）分区信息 2）原始数据key的起始位置 3）原始数据value的起始位置 4）value的长度信息 长度是固定的（4 * 16） 原始数据：序列化的数据 map输出的key 、value的键值对 环形缓冲区 byte [] 缓冲区中：分界线 辨识元...
mapreduce高级特性及shuffle
10-22
1.shuffle机制详细讲解 2.MR案例多文件输出 3.MR案例partition使用 4.MR案例内容去重 5.MR案例敏感词汇过滤 6.MR案例自定义combiner的使用 7.MR案例倒排序索引 8.MR案例简单排序
MapReduce详解Shuffle过程
03-16
MapReduce详解Shuffle过程
【MapReduce篇05】MapReduce之Shuffle机制1
08-04
（1）如果 Reduce Task的数量> getPartition的结果数，则会多产生几个空的输出文件part-r-000Xx （2）如果1< ReduceT
MapReduce的shuffle过程详解（分片、分区、合并、归并。。。）
热门推荐
ASN_forever的博客
07-29 5万+
shuffle过程 shuffle概念 shuffle的本意是洗牌、混洗的意思，把一组有规则的数据尽量打乱成无规则的数据。而在MapReduce中，shuffle更像是洗牌的逆过程，指的是将map端的无规则输出按指定的规则“打乱”成具有一定规则的数据，以便reduce端接收处理。其在MapReduce中所处的工作阶段是map输出后到reduce接收前，具体可以分为map端和reduce端前后两...
大数据计算框架——MapReduce（内含详细的shuffle过程）
cc的博客
06-01 1626
MapReduce1. MapReduce模型简介2. Map 和 Reduce 函数2.1 Map函数2.2 Reduce函数2.3 两个函数的关系图3. MapReduce工作流程3.1 工作流程概述（注意两点）3.2 工作流程图片说明4. MapReduce执行的各个阶段4.1 共6个阶段二级目录二级目录 1. MapReduce模型简介 MapReduce同样是谷歌公司的MapReduce的开源实现，其要比谷歌的MapReduce的使用门槛低很多。MapReduce将复杂的、运行于大规模集群上的并行
MapReduce shuffle过程详解！
蔡政洁的博客
10-12 8110
目录一、MR的shuffle过程二、Map shuffle三、Reduce shuffle 一、MR的shuffle过程 MR的shuffle过程： input -> map -> shuffle -> reduce ->output MR的原理图： 二、Map shuffle 1.map()的数据会写入到内存（环形缓冲区：默认大小：100mb），当数据达到缓冲区总容量的80%（阈值）时，会将我们的数据spill到本地磁盘 1）分区（partitioner）：分
MapReduce的shuffle机制
eyexin2018的博客
11-23 1191
MapReduce原理篇 1.1 MapReduce的shuffle机制 1.1.1 概述：  mapreduce中，map阶段处理的数据如何传递给reduce阶段，是mapreduce框架中最关键的一个流程，这个流程就叫shuffle；  shuffle: 洗牌、发牌——（核心机制：数据分区，排序，缓存）；  具体来说：就是将maptask输出的处理结果数据，分发给reducetask，并在分发的过程中，对数据按key进行了分区和排序； 1.1.2 主要流程： Shuffle缓存流程： shu.
MapReduce shuffle过程详解
thinkhui的专栏
03-25 9367
一、MapReduce计算模型 MapReduce计算模型主要由三个阶段构成：Map、Shuffle、Reduce。 Map是映射，负责数据的过滤分法，将原始数据转化为键值对；Reduce是合并，将具有相同key值的value进行处理后再输出新的键值对作为最终结果。为了让Reduce可以并行处理Map的结果，必须对Map的输出进行一定的排序与分割，然后再交给对应的Reduce，而这个将Map输出进...
MapReduce的Shuffle机制
qianyulin
01-07 8982
1、MapReduce的shuffle机制 1.1、概述  MapReduce中，mapper阶段处理的数据如何传递给reduce阶段，是MapReduce框架中最关键的一个流程，这个流程就叫shuffle. Shuffle:数据混洗---------（核心机制：数据分区，排序，局部聚合，缓存，拉取，再合并排序） 具体来说，就是将MapTask输出的处理数据结果，按照Partitioner...
MapReduce学习三：Shuffle
qq_35515283的博客
01-20 2156
一、MapReduce详细工作流程 Map阶段 reduce阶段 二、Shuffle机制 流程图 Map方法之后，Reduce方法之前的数据处理过程称之为Shuffle。 2.1Partition分区 分区指的是：将MapReduce统计的结果按照条件输出到不同的文件中。 public int getPartition(K key,V value,int numReduceTasks){ return (key.hashCode()&Intger.MAX_.
MapReduce执行流程和Shuffle过程
01-07
本节将对 Hadoop MapReduce 的工作机制进行介绍，主要从 MapReduce 的作业执行流程和 Shuffle 过程方面进行阐述。通过加深对 MapReduce 工作机制的了解，可以使程序开发者更合理地使用 MapReduce 解决实际问题。 ...
FocusBigData:【大数据成神之路学习路径+面经+简历】
05-07
FocusBigData :elephant:Hadoop分布存储框架 Hadoop篇 HDFS篇 HDFS客户端操作 --- 开发环境准备 HDFS客户端操作 --- 文件操作 ...MapReduce之Shuffle机制 MapReduce之MapJoin和ReduceJoin MapReduce之
七个pdf理解spark系列_4-shuffleDetails
07-02
GitHub上某位大牛JerryLead对Spark的理解，大量图示，生动形象，总共7个pdf，看完对spark的原理，运行机制以及后续性能调优有很大的帮助，这是第四个pdf，描述了shuffle的细节，对比了MapReduce与spark的shuffle过程...
Linux命令大全 以及搭建hadoop
ziaoming_biu的博客
04-28 692
这个网卡就代表本机，自身。ip address、ip a、ip addr、ip ad、ifconfig（需要先安装net-tools）查看到的比ip a系列的要详细些，能够查看到接收的包和传输的包。sed：Stream EDitor，流编辑器，可以按照特定规则按行编辑数据（sed是不处理原数据的，编辑完的行默认是打印到屏幕，所以sed运行完原文件内容是不变的）-ok 和-exec的作用相同，只不过以一种更为安全的模式来执行该参数所给出的命令，在执行每一个命令之前，都会给出提示，让用户来确定是否执行。
Hadoop - 安装
伊织看世界
04-24 1379
关于 Hadoop 架构变迁 1.0 --> 2.0 --> 3.0 安装配置 安装 配置环境变量 配置 core-site.xml hdfs-site.xml mapped-site.xml yarn-site.xml 配置 hadoop-env 启动/停止 Hadoop 服务 查看 hdfs report
MapReduce
qq_14846625的博客
04-30 517
目的: 分析 MR (MapReduce) 作业的执行流程。流程维度: 从节点、状态节点、角色进程等角度进行分析。
chromedriver-linux64-V124.0.6367.91 稳定版
04-30
chromedriver-linux64-V124.0.6367.91稳定版
基于yolov7 加入 depth回归
最新发布
04-30
在官方的基础上改了检测头、导出onnx（适配tensorrt pro 项目）、测试demo等代码。 能够使用清华V2X数据集进行训练和测试。 https://www.bilibili.com/video/BV1Wd4y1G78M/?vd_source=0223c707743ff3013adaeff54aee3506 数据集来源：https://thudair.baai.ac.cn/index 基于Yolov7 tiny，加入了距离回归 模型没收敛完，随便试了下，所以预测有抖动 使用TRT加速，在AGX Xavier上推理大约4ms V2X使用tools/convertlabel2yolo.ipynb 进行数据集转换
mapreduce的shuffle原理
09-08
MapReduce的shuffle机制是指在MapReduce计算模型中，将Map阶段处理的数据传递给Reduce阶段的关键流程。Shuffle的核心机制包括数据分区、排序和缓存。具体来说，Shuffle将Map任务输出的处理结果数据分发给Reduce任务...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值