day04 hadoop（mr底层原理）

于 2021-11-14 00:52:23 发布
阅读量1.3k 收藏
点赞数
分类专栏： hadoop 文章标签： hadoop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yygyj/article/details/121311670
版权

案例一：单词对应的目录统计

//按照分数降序排序
	@Override
	public int compareTo(Score o) {
		return o.score-this.score;
	}

package cn.tedu.invert;

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.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class InvertDriver {

	public static void main(String[] args) throws Exception {
		Configuration conf = new Configuration();
		Job job = Job.getInstance(conf, "JobName");
		job.setJarByClass(cn.tedu.invert.InvertDriver.class);
		job.setMapperClass(InvertMapper.class);
		job.setReducerClass(InvertReducer.class);

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

		FileInputFormat.setInputPaths(job, new Path("hdfs://192.168.253.129:9000/mr/invert/"));
		FileOutputFormat.setOutputPath(job, new Path("hdfs://192.168.253.129:9000/result/invert"));

		if (!job.waitForCompletion(true))
			return;
	}

}


package cn.tedu.invert;

import java.io.IOException;

import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.lib.input.FileSplit;
/*
 * 单词对应的目录统计
 *  */
public class InvertMapper 
	extends Mapper<LongWritable, Text, Text, Text> {

	public void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
		//获取文件名
		FileSplit fs=(FileSplit)context.getInputSplit();
		String name=fs.getPath().getName();
		
		//拆分单词
		String[] arr=value.toString().split(" ");
		for (String str : arr) {
			//单词放前边，文件名放后边
			context.write(new Text(str), new Text(name));
		}
	}

}


package cn.tedu.invert;

import java.io.IOException;
import java.util.HashSet;
import java.util.Set;

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

public class InvertReducer extends Reducer<Text, Text, Text, Text> {

	public void reduce(Text key, Iterable<Text> values, Context context) throws IOException, InterruptedException {
		// 考虑文件名的去重问题
		Set<String> set=new HashSet<>();
		
		for (Text val : values) {
			set.add(val.toString());
		}
		
		StringBuilder sb=new StringBuilder();
		for (String str : set) {
			sb.append(str).append("\t");
		}
		context.write(key, new Text(sb.toString()));
	}

}

案例二：按月份统计每一个人的总成绩

package cn.tedu.partscore;

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

public class MonthPartitioner extends Partitioner<Text,Score>{

	@Override
	public int getPartition(Text key, Score value, int numReduceTasks) {
		// 按月份进行分类
		//1 2 3 
		//0 1 2
		return value.getMonth()-1;
	}

}


package cn.tedu.partscore;

import org.apache.hadoop.conf.Configuration;
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.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class PartScoreDriver {

	public static void main(String[] args) throws Exception {
		Configuration conf = new Configuration();
		Job job = Job.getInstance(conf, "JobName");
		job.setJarByClass(cn.tedu.partscore.PartScoreDriver.class);
		job.setMapperClass(PartScoreMapper.class);
		job.setReducerClass(PartScoreReducer.class);
		job.setPartitionerClass(MonthPartitioner.class);
		job.setNumReduceTasks(3);
		job.setMapOutputKeyClass(Text.class);
		job.setMapOutputValueClass(Score.class);
		
		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(IntWritable.class);

		FileInputFormat.setInputPaths(job, new Path("hdfs://192.168.253.129:9000/mr/score1/score1.txt"));
		FileOutputFormat.setOutputPath(job, new Path("hdfs://192.168.253.129:9000/result/score1"));

		if (!job.waitForCompletion(true))
			return;
	}

}


package cn.tedu.partscore;

import java.io.IOException;

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

public class PartScoreMapper 
	extends Mapper<LongWritable, Text, Text, Score> {

	public void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
		String[] arr=value.toString().split(" ");
		Score s=new Score();
		s.setMonth(Integer.parseInt(arr[0]));
		s.setName(arr[1]);
		s.setScore(Integer.parseInt(arr[2]));
		context.write(new Text(s.getName()), s);
	}

}


package cn.tedu.partscore;

import java.io.IOException;

import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.Reducer;
/*
 * 按月份统计每一个人的总成绩
*/
public class PartScoreReducer 
	extends Reducer<Text, Score, Text, IntWritable> {

	public void reduce(Text key, Iterable<Score> values, Context context) throws IOException, InterruptedException {
		int sum=0;
		for (Score val : values) {
			sum+=val.getScore();
		}
		context.write(key, new IntWritable(sum));
	}

}


package cn.tedu.partscore;

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

import org.apache.hadoop.io.Writable;

public class Score implements Writable{
	private int month;
	private String name;
	private int score;
	public int getMonth() {
		return month;
	}
	public void setMonth(int month) {
		this.month = month;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getScore() {
		return score;
	}
	public void setScore(int score) {
		this.score = score;
	}
	@Override
	public String toString() {
		return "Score [month=" + month + ", name=" + name + ", score=" + score + "]";
	}
	@Override
	public void readFields(DataInput in) throws IOException {
		this.month=in.readInt();
		this.name=in.readUTF();
		this.score=in.readInt();
		
	}
	@Override
	public void write(DataOutput out) throws IOException {
		out.writeInt(month);
		out.writeUTF(name);
		out.writeInt(score);
		
	}
	
}

二、分区- Partition
1.分区的作用是将数据进行分类
2.有无分区并不影响Map和Reduce的执行逻辑
3．分区默认是从O开始依次递增的
4．在MapReduce中，每一个分区要对应一个ReduceTask，每一个ReduceTask都会产生一个结果文件。默认情况下只有1个分区，也就只有1个ReduceTask，只产生一个结果文件
5．在MapReduce中，如果没有手动指定Partitioner，那么默认使用的分区类是
HashPartitioner

将姓名和分数输出（分数是降序）

package cn.tedu.sortscore;

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

import org.apache.hadoop.io.WritableComparable;
//序列化和排序
public class Score implements WritableComparable<Score>{
	private String name;
	private int score;
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getScore() {
		return score;
	}
	public void setScore(int score) {
		this.score = score;
	}
	@Override
	public String toString() {
		return "Score [name=" + name + ", score=" + score + "]";
	}
	@Override
	public void readFields(DataInput in) throws IOException {
		this.name=in.readUTF();
		this.score=in.readInt();
		
	}
	@Override
	public void write(DataOutput out) throws IOException {
		out.writeUTF(name);
		out.writeInt(score);
		
	}
	//按照分数降序排序
	@Override
	public int compareTo(Score o) {
		return o.score-this.score;
	}
	
}


package cn.tedu.sortscore;

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

public class SortScoreDriver {

	public static void main(String[] args) throws Exception {
		Configuration conf = new Configuration();
		Job job = Job.getInstance(conf, "JobName");
		job.setJarByClass(cn.tedu.sortscore.SortScoreDriver.class);
		job.setMapperClass(SortScoreMapper.class);
		job.setReducerClass(SortScoreReducer.class);

		job.setMapOutputKeyClass(Score.class);
		job.setMapOutputValueClass(NullWritable.class);
		job.setOutputKeyClass(Text.class);
		job.setOutputValueClass(IntWritable.class);
		
		//_开头的文件在MapReducer中被认为是一个隐藏文件不被读取
		FileInputFormat.setInputPaths(job, new Path("hdfs://192.168.253.129:9000/mr/sortscore/score2/"));
		FileOutputFormat.setOutputPath(job, new Path("hdfs://192.168.253.129:9000/result/sortscore"));

		if (!job.waitForCompletion(true))
			return;
	}

}


package cn.tedu.sortscore;

import java.io.IOException;

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

public class SortScoreMapper 
	extends Mapper<LongWritable, Text, Score, NullWritable> {

	public void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
		String[] arr=value.toString().split("\t");
		Score s=new Score();
		s.setName(arr[0]);
		s.setScore(Integer.parseInt(arr[1]));
		context.write(s, NullWritable.get());
	}

}


package cn.tedu.sortscore;

import java.io.IOException;

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

public class SortScoreReducer 
	extends Reducer<Score, NullWritable, Text, IntWritable> {

	public void reduce(Score key, Iterable<NullWritable> values, Context context) throws IOException, InterruptedException {
		// 
		context.write(new Text(key.getName()), new IntWritable(key.getScore()));
		
	}

}

三、排序
1．在MapReduce中，自动对键进行排序
2．要求键所对应的类必须实现Comparable接口，但是考虑到键需要序列化，所以一般实现的WritableComparable
3．在排序过程中，如果compareTo方法的返回值为o，则MapReduce会认为这两个键是同一个，则将这两个键的值放到一组(去重操作)，是个bug

案例：练习∶按照月份升序排序，如果月份一样，则按照利润降序排序(文件:profit2.txt )

package cn.tedu.sortprofit;

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

import org.apache.hadoop.io.WritableComparable;

public class Profit implements WritableComparable<Profit>{
	private int month;
	private String name;
	private int profit;
	public int getMonth() {
		return month;
	}
	public void setMonth(int month) {
		this.month = month;
	}
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public int getProfit() {
		return profit;
	}
	public void setProfit(int profit) {
		this.profit = profit;
	}
	@Override
	public String toString() {
		return "Profit [month=" + month + ", name=" + name + ", profit=" + profit + "]";
	}
	@Override
	public void readFields(DataInput in) throws IOException {
		this.month=in.readInt();
		this.name=in.readUTF();
		this.profit=in.readInt();
	}
	@Override
	public void write(DataOutput out) throws IOException {
		// 
		out.writeInt(month);
		out.writeUTF(name);
		out.writeInt(profit);
	}
	//先按照月份排序，如果月份一致则按照利润降序
	@Override
	public int compareTo(Profit o) {
		int r1=this.month-o.month;
		if(r1==0){
//			return o.profit-this.profit;//有去重的bug
			int r2=o.profit-this.profit;
			return r2==0 ? 1:r2;
		}
		return r1;
	}
	
}


package cn.tedu.sortprofit;

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.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;

public class ScoreProfitDriver {

	public static void main(String[] args) throws Exception {
		Configuration conf = new Configuration();
		Job job = Job.getInstance(conf, "JobName");
		job.setJarByClass(cn.tedu.sortprofit.ScoreProfitDriver.class);
		job.setMapperClass(ScoreProfitMapper.class);
		job.setReducerClass(ScoreProfitReducer.class);

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

		FileInputFormat.setInputPaths(job, new Path("hdfs://192.168.253.129:9000/mr/profit2/profit2.txt"));
		FileOutputFormat.setOutputPath(job, new Path("hdfs://192.168.253.129:9000/result/profit2"));

		if (!job.waitForCompletion(true))
			return;
	}

}


package cn.tedu.sortprofit;

import java.io.IOException;

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

public class ScoreProfitMapper extends Mapper<LongWritable, Text, Profit, NullWritable> {

	public void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
		String[] arr=value.toString().split(" ");
		Profit p=new Profit();
		p.setMonth(Integer.parseInt(arr[0]));
		p.setName(arr[1]);
		p.setProfit(Integer.parseInt(arr[2]));
		context.write(p, NullWritable.get());
	}

}


package cn.tedu.sortprofit;

import java.io.IOException;

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

public class ScoreProfitReducer 
	extends Reducer<Profit, NullWritable, Profit, NullWritable> {

	public void reduce(Profit key, Iterable<NullWritable> values, Context context) throws IOException, InterruptedException {
		context.write(key, NullWritable.get());
	}

}

四、合并-Combine
1.大多数情况下，MapTask的数量要远远多于ReduceTask的数量，导致计算压力几乎全部落在了ReduceTask上，ReduceTask的计算效率就成为整个MapReduce的瓶颈job.setCombinerClass(Reducer.class);
2．合并的逻辑和Reducer的逻辑是一样的-只需要在Driver中添加

3．合并的特点:减少数据总量但是不改变计算结果
4．如果进行汇总、获取最值、去重之类操作可以使用Combiner，但是例如求平均之类的操作不能使用Combiner

求平均不适合Combine
在这里插入图片描述
细节
一、数据本地化策略
1.当JobTracker收到MR程序的时候，会访问NameNode获取文件信息。文件
信息包含文件大小以及块信息
2.JobTracker对这个文件进行切片处理。注意:切片是逻辑切分不是物理切分。切片数量决定了MapTask的数量。默认情况下，Split和Block是等大的
3.JobTracker会将划分出来的MapTask分配到TaskTracker上执行
4．因为MapTask在执行过程中需要读取数据，而数据在DataNode上，所以将
DataNode和TaskTracker部署在相同的节点上以减少跨集群的网络传输
5．为了减少网络资源的消耗，在分配任务的时候会考虑Block的位置。哪个节点
上有要处理的数据，将任务分配给哪个节点，这个过程称之为数据本地化

在这里插入图片描述
在这里插入图片描述
6.切片产生过程︰
a．如果文件为空，则整个文件作为一个切片处理
b．在MapReduce中，文件要区分可切或者不可切，例如绝大部分的压缩文件就是不可切的
c.如果文件不可切，则整个文件作为一个切片处理
d．如果需要减小splitsize，需要调小maxsize;如果需要调大splitsize ，需要调大minsize
e.在计算切片的时候，需要考虑切片阈值– SPLIT_SLOP =1.1

二、MR执行流程
1.准备阶段︰
a．检查输入和输出路径
b.计算切片数量
c．如果有必要，设置缓存存根
d．将jar包和配置上传到HDFS上
e．将任务提交给JobTracker，并且可以选择是否监控这个任务

2.执行阶段∶
a. JobTracker收到Job任务之后，会将这个任务进行拆分，拆分成MapTask
和ReduceTask。MapTask的数量由切片决定;ReduceTask的数量由分区数量决定
b. JobTracker在拆分完成任务之后，会等待TaskTracker的心跳，然后给TaskTracker分配任务。分配任务的时候，MapTask尽量满足数据本地化策略，ReduceTask无法满足数据本地化，所以ReduceTask在分配的时候是考虑节点的空闲
c. TaskTracker通过心跳领取任务，领取到任务之后，会去对应节点上下载jar包，这一步体现的思想是逻辑移动数据固定
d. TaskTracker会在本节点上开启JVM子进程执行MapTask或者ReduceTask。注意:每一个MapTask或者ReduceTask的执行都会开启一次JVM子进程

shuffle
—、Map益的shuffle
1.map方法在处理完成数据之后会将结果写出到MapTask自带的缓冲区中-每一个MapTask自带一个缓冲区- MapOutputCollector

2．数据在缓冲区中进行分区、排序，如果指定了Combiner，那么数据在缓冲区中还会进行combine。注意:在缓冲区中的排序是将完全无序的数据整理成有序数据，采取的是快速排序

3．缓冲区是维系在内存中，默认是100M
4．当缓冲区的使用达到一定限度（溢写阈值:0.8）的时候，会将缓冲区中的数
据溢写(spill)到磁盘上，map方法后续产生的结果会继续写到缓冲区中
5.每一次溢写都会产生一个新的溢写文件-单个溢写文件中的数据是分区且有序的，所有的溢写文件是局部有序的

6．在map方法完成之后，将所有的溢写文件进行合并(merge)，将所有的溢写文件合并成一个结果文件(final out)，在merge过程中，数据会再次进行分区排序- final out是整体分区且有序的.merge过程中的排序是将局部有序变成整体有序，所以采取的是归并排序。

7.如果map方法执行完成之后，缓冲区中依然有数据，则会直接合并到最后的final out中
8.在merge过程中，如果spill文件个数>=3并且指定了Combiner，则在merge的时候会再进行一次combine

9．注意问题:
a. spill过程不一定产生
b．默认情况下，溢写文件的大小不一定是80M，考虑序列化因素（可能只序列化一部分内容）
c．缓冲区本质上是一个环形的字节数组，设置为环形的目的是为了避免寻址，能够重复利用缓冲区
d．阈值的作用是为了减少写入的阻塞

二、Reduce端的shuffle

1.ReduceTask启动多个fetch线程去MapTask处抓取对应分区的数据
2.ReduceTask将从每一个MapTask上抓取过来的数据存储在一个本地文件中
3.将抓取来数据进行一次merge，合并成一个大文件，在merge过程中，会再次进行排序，采用的是归并排序
4. merge完成之后，ReduceTask会再将相同的键对应的值放到一个迭代器中，这个过程称之为分组(group)
5．分组完成之后，每一个键对应一个迭代器，每一个键调用一次reduce方法

6.注意问题:
a. ReduceTask的启动阈值:0.05-当5%的MapTask结束，就会启动ReduceTask去抓取数据

b. fetch线程通过HTTP请求获取数据
c. fetch线程的数量默认为5
d. merge因子:10 -每10个小文件合并成1个大文件

在这里插入图片描述

搭建Hadoop需要的服务器类型：倾向于内存比较好的服务器

快乐咸鱼Y
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Day39~40_Hadoop之MapReduce（二）
qq_36972345的博客
08-31 208
<!-- 历史服务器端地址 --> <property> <name>mapreduce.jobhistory.address</name> <value>bd-offcn-01:10020</value> </property> <!-- 历史服务器web端地址 --> <property> <name>mapreduce.jobhistory.webapp...
Hadoop基础组件思维导图
pengley的博客
07-10 1200
前提
MR工作原理总结
11-05
简单的描述了一下MR在map端和reduce上进行工作的原理，纯属个人理解，如果有不当的地方，可以说
Hadoop MR 核心原理
Be yourself.
04-07 5641
前言 在之前的系列内, 多数都是介绍Hadoop MR的基本操作, 对于运行原理涉及较少. 本章, 主要补充下这部分的内容. 方便以后的理解. 本章主要分为如下几个部分: 正文 WordCount运行设计 WordCount的Map/Reduce主要分为如下几个阶段: Mapper主要负责任务的初级处理, Reducer主要负责数据的合并; Mapper端的操作为(读取数据/按行处理/每行按空...
Shuffle
weixin_43356218的博客
11-10 237
1.Map端的Shuffle 1.MapTask在拿到切片之后，默认会对数据进行按行读取，每读取一行默认调用一次map方法来进行处理 2.每一个MapTask默认自带一个缓冲区，map方法执行的结果会临时的写到缓冲区中 3.缓冲区是维系在内存中，默认是100M 4.当缓冲区达到一定条件的时候，就会将缓冲区中的数据写到磁盘上，这个过程称之为溢写(spill) 5.溢写之后，map方法产生的结果会继...
hadoop MR运行原理
jie310600的博客
08-25 802
hadoop MR运行原理 [url]http://s5.51cto.com/wyfs02/M01/86/7B/wKiom1fADFHCZ-igAAFuYAeFdr0171.png-wh_500x0-wm_3-wmp_4-s_2360924780.png[/url] [url]https://www.cnblogs.com/dream-to-pku/p/7249954.html[/ur...
hadoop详细笔记(十五) MR原理加强(mapreduce内部处理数据流程和shuffle详解)
HANG.NIAN
07-14 1535
1 MR内部处理数据流程 mr程序分为map端和reduce端,来进行处理数据,mr程序在运行的时候最先启动的程序就是MRAppMaster,MRAppMaster是可以读到在job提交的时候的参数信息,所以它可以根据参数信息,来启动对应数量的maptask和reducetask,在maptask启动后,会读取自己对应的任务切片,以逐行读取的方式,一个K,V执行一次map()方法,K为起始偏移量,V为行内容 在map()方法执行完一次后,会将数据写入到环形缓冲区中,当环形环形缓冲区中的数据存储达到
Hadoop课程知识点总结
weixin_43800143的博客
05-16 1091
第一章 大数据概述 大数据的定义 大数据是指无法在一定时间内用常规软件工具对其 内容进行抓取、管理和处理的数据集合，比如：与人类社会活动有关的网络数据。 三次信息浪潮 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YEQyrrZq-1621149351322)(D:\Program Files\Typora\学习文档\复习\hadoop复习\img\image-20210515162847423.png)] 信息技术为大数据提供的技术支撑 存储设备容量不断增加 CPU处理能
Hadoop学习
weixin_41560737的博客
08-25 394
Day01 1. 大数据简介 1.1 大数据的由来 随着计算机技术的发展，互联网的普及，信息的积累已经到了一个非常庞大的地步，信息的增长也在不断的加快，随着互联网、物联网建设的加快，信息更是爆炸式增长，收集、检索、统计这些信息越发困难，必须使用新的技术来解决这些问题 1.2 什么是大数据 【1】定义 大数据指无法在一定时间范围内用常规软件工具进行捕捉、管理和处理的数据集合，需要新处理模式才能具有更强的决策力、洞察发现力和流程优化能力的海量、高增长率和多样化的信息资产 【2】总结 大数据是指即从各
HADOOP总结
wywwyx090104的博客
06-11 346
HADOOP总结 Hadoop(Hadoop的特点: (1) 高可靠性 : Hadoop底层将数据以多个副本的形式存储在不同的机器上,保证数据的安全可靠。 (2) 高扩展性 ：当存储hdp集群的存储能力和运算资源不足时,可以横向的扩展机器节点来达到扩容和增强运算能力 。 (3) 高效性 ：在MapReduce的思想下能够在节点之间动态地移动运算,且是分布式并行工作的,所以运海量数据非常高效。 (4) 高容错性 ： Hadoop能够自动保存数据的多个副本，当有存储数据的节点宕机以后, 会自动的复制副本维持集
Hadoop技术内幕_MR
02-13
Hadoop技术内幕，适合新手阅读，容易上手，共同赏阅。
Hadoop基本知识，（以及MR编程原理）
longshenlmj的专栏
12-09 4216
1，一个map可能在多个节点上运行：     如果map运行过慢，就会在别的节点上重开一个，两个谁先跑完就取谁的结果，然后杀掉另一个。   2，如果有百个节点左右的集群想要做hadoop版本升级，有没有什么好办法？希望能稳定，最好不影响每天凌晨的定时作业。      升级一般都要一起升，因为是跨版本。如果是不跨版本，比如1.x中各版本之间升级则可以不用。如果是1.0升到2.0，则需要停集
Hadoop总结之MR
Autter的博客
06-29 1034
1.思考 MR的缺点？ 不擅长实时计算 hadoop 的 文件是存储磁盘的 hdfs 内，传输相比内传会慢很多，相比较 Storm 和 Spark 的流处理，流处理不需要批处理的数据收集时间，也省去； 作业调度的时延。 不擅长流式计算 流式计算的输入数据是动态的，但是MR 的输入数据集时静态的，不能动态变化。 不擅长有向图的计算 多个应用存在依赖关系，后一个程序的输入是前一个的输出。MR 不能进行这样的计算，因为每个 MR 结果都会写入到磁盘，会造成大量的 IO,导致性能非常低下。 2.讲一下MR的工作
【Hive】Join的 MR 底层原理
康师傅没有眼泪
04-10 4935
Hive Map Join如果不指定MapJoin或者不符合MapJoin的条件，那么Hive解析器会将Join操作转换成Common Join,即：在Reduce阶段完成join. 整个过程包含Map、Shuffle、Reduce阶段。读取源表的数据，Map输出时候以 Join on 条件中的列为key，如果Join有多个关联键，则以这些关联键的组合作为key; Map输出的 value 为 join 之后所关心的(select或者where中需要用到的)列...
Hadoop详解(四)——Shuffle原理，Partitioner分区原理，Combiner编程，常见的MR算法
09-02 8203
Partitioner编程Partition简介shuffle是通过分区partitioner 分配给Reduce的 一个Reducer对应一个记录文件Partitioner是shuffle的一部分partitioner执行时机：在mapper执行完成，Reducer还没有执行的时候，mapper的输出就是partitioner的输入 即partitioner 分区主要是用来提高效率的 例如从全国
hadoop生态系统之MR详解
Child2的博客
03-12 3448
笔者将以第一人称视角向各位阐述MR，从两个大方向描述MR旨在将自己所学所会融进这套知识体系。 1. 站在系统设计的角度讲讲MR在hadoop生态系统中上下游扮演的角色起到了什么作用及为什么需要MR 2.技术性细节，MR的整个工作流程 如有不到之处烦请指正 一 宏观剖析 1 MR是什么？ MapReduce是一种计算模型，用以进行大数据量的计算。其中Map对数据集上的独立元素进行指定的操作，生...
大数据-hadoop之MR
zZsSzss的博客
07-29 1102
MapReduce维基百科 MR是一个分布式运算框架,主要分为Map和reduce两个阶段,map负责把一个任务分解成多个任务,reduce负责把分解后多个任务的处理结果汇总 优缺点 ① 易编程,简单的实现一些接口,就可以完成一个分布式程序,可以分布到大量机器上运行. ② 易扩展, 当计算力不够的时候,可以通过简单的增加机器来扩展计算能力 ③ 高容错, 当一个机器挂了,可以把上面的计算任务转移到另一个节点上,不至于任务失败 ④ 大数据量, 可以实现上千台服务器集群并发工作,提供数据处理能力 缺点..
2.MR基础_工作原理
风不止步的博客
10-12 1108
一.MapReduce运行机制 Client：提交MapReduce作业 ResourceManager：负责集群资源的统一管理和调度 NodeManager：它主要负责自己本身节点的资源管理和使用，以及定时向RM汇报本节点的资源使用情况 ApplicationMaster：主要负责应用程序的管理 HDFS：在其他角色间共享数据文件 二.MapReduce框架 MapReduce作...
Hadoop原理和特性
程序员世杰
03-22 1888
一、Hadoop （一）定义 Hadoop 是一个由 Apache 基金会所开发的分布式系统基础架构。用户可以在不了解分布式底层细节的情况下，开发分布式程序。充分利用集群的威力进行高速运算和存储。Hadoop 实现了一个分布式文件系统（Hadoop Distributed File System），简称 HDFS。HDFS 有高容错性的特点，并且设计用来部署在低廉的（low-cost）硬件上；而且...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值