大数据时代：Hadoop架构及其组件详解

m0_65552477

845人浏览 · 2026-01-05 20:47:03

m0_65552477 · 2026-01-05 20:47:03 发布

大数据时代：Hadoop架构及其组件详解

关键词：Hadoop、HDFS、MapReduce、YARN、分布式计算、大数据存储、资源管理

术语表

核心术语定义

HDFS（Hadoop Distributed File System）：Hadoop的分布式文件系统，负责把海量文件拆分成小块，分散存储在多台机器上。
MapReduce：Hadoop的分布式计算模型，将复杂任务拆分为“分任务”（Map）和“合结果”（Reduce）两步，像流水线一样并行处理。
YARN（Yet Another Resource Negotiator）：Hadoop的资源管理框架，负责给计算任务分配机器、内存等资源，相当于“任务调度员”。
Hadoop 是一个由 Apache 基金会开源的 大数据处理框架，用于处理大规模的数据集。它可以将数据分布存储在集群中，并提供高效的并行计算能力。你可以将它理解为：在传统数据库和应用程序之间，加了一层可以“搞定海量数据”的中间件系统。

为什么需要 Hadoop？

数据规模已经从 GB 级跃升到 TB、PB 级
传统数据库（如 MySQL）无法水平扩展
读写和计算性能无法满足大规模数据需求

设计原则

可扩展性：支持 10,000+ 节点集群
高可用性：关键组件无单点故障
多租户支持：资源隔离与配额管理
兼容性：无缝支持 MapReduce 应用
灵活性：支持多种计算框架

Hadoop 的设计目标就是：让普通的廉价机器组成集群，像超级计算机一样干活。

[用户/应用]
     ↓
[传统 MySQL（性能瓶颈）]
     ↓（替代）
[Hadoop 框架（中间层）]

核心概念与联系

故事引入：从“图书馆管书”到“工厂加工书”

假设你是一家“全球最大图书馆”的管理员，每天有1000吨新书送来（数据量爆炸）。如果用传统方法——把所有书堆在1个大房间（单机存储），会遇到3个问题：

房间装不下（单机存储容量有限）；
找书太慢（单机检索效率低）；
房间塌了书全丢（单机故障数据丢失）。

于是你想了个办法：

分书架存书（HDFS）：把书拆成128页的小册子（数据块），每个小册子复印3份（副本），分散放到100个小房间（从节点机器）的书架上，每个小房间有1个“小管家”记录自己存了哪些小册子。
流水线加工书（MapReduce）：现在要统计全馆“爱情”关键词出现次数，不能让1个人逐本翻（太慢），而是让100个工人（分布式计算）同时翻各自房间的书（Map阶段：统计各自房间的“爱情”次数），再让10个组长把工人的结果合并（Reduce阶段：把100个结果相加）。
调度员管工人（YARN）：但工人可能同时要干多个任务（统计“爱情”“战争”等），需要1个调度员分配谁去翻书、谁去合并，避免工人打架（资源冲突）。

这三个办法，就是Hadoop的三大核心组件：HDFS（分书架存书）、MapReduce（流水线加工）、YARN（调度员管资源）。

核心概念解释

核心概念一：HDFS——分布式文件系统（分书架存书）

HDFS就像一个“超级分散的图书馆”，它的目标是：存得下、找得到、丢不了。

存得下：把大文件拆成128MB的“数据块”（比如10GB的电影拆成80个128MB的小块），每个块分散存到不同机器（从节点）。
类比：你有1000本1000页的书，直接塞书架会挤爆，所以把每本书撕成128页的小册子（数据块），每个小册子放到不同抽屉（机器）。
找得到：有1个“总管家”（NameNode主节点）记录每个数据块存在哪台机器。比如你要找《哈利波特》，总管家会告诉你：“第1块在3号机器，第2块在5号机器……”
类比：图书馆有1张总地图（元数据），标着“《哈利波特》第1册在A区3排，第2册在B区5排”。
丢不了：每个数据块默认复制3份（副本），存到不同机器。如果某台机器坏了（比如3号机器停电），总管家会立刻让其他机器（比如存了3号机器副本的8号机器）补上。
类比：重要文件复印3份，分别放办公室、家里、银行保险柜，丢了1份还有2份。

核心概念二：MapReduce——分布式计算模型（流水线加工）

MapReduce是Hadoop的“计算引擎”，它的核心思想是：分而治之，先拆后合。就像工厂加工零件，先让100个工人同时加工（Map阶段），再让10个组长合并结果（Reduce阶段）。

Map阶段（拆分任务）：把大任务拆成多个小任务，每个小任务由1台机器处理。
例子：统计全馆“爱情”出现次数，Map阶段让每台机器（从节点）统计自己存的所有书里“爱情”出现的次数（比如3号机器统计后得到100次，5号机器得到200次）。
Shuffle阶段（搬运结果）：把Map阶段的中间结果（比如各机器的“爱情:100”“爱情:200”）搬运到对应的Reduce机器，准备合并。
类比：工人把各自的零件（统计结果）装进箱子，贴上“爱情组”“战争组”的标签，搬到对应的组长办公室。
Reduce阶段（合并结果）：每个Reduce机器把同一类的中间结果合并，得到最终答案。
例子：“爱情组”组长把所有“爱情:100”“爱情:200”相加，得到总次数300次。

核心概念三：YARN——资源管理框架（调度员管工人）

YARN是Hadoop的“大管家”，负责给任务分配资源（机器、内存、CPU），确保任务不“打架”。

ResourceManager（总调度员）：管全局资源，比如整个集群有100台机器，它决定哪些机器给“统计爱情”任务，哪些给“统计战争”任务。
类比：工厂老板，手里有100个工人，决定今天派50人去A流水线，30人去B流水线。
NodeManager（机器小管家）：每台机器的“小调度员”，负责监控本机资源（比如内存用了多少，CPU忙不忙），并向总调度员汇报。
类比：每个车间的组长，记录本车间还有多少空工位，告诉老板“3号车间还剩10个工人空闲”。
ApplicationMaster（任务小领导）：每个任务的“小队长”，向总调度员申请资源（比如需要5台机器跑Map，2台跑Reduce），并监控任务进度（比如Map完成80%，Reduce刚开始）。
类比：A流水线的负责人，找老板要10个工人，然后盯着工人有没有偷懒。

核心概念之间的关系

HDFS、MapReduce、YARN的关系，就像“图书馆+工厂+调度中心”的协作：

HDFS和MapReduce的关系：HDFS是“原材料仓库”，MapReduce是“加工工厂”。工厂要加工零件（计算数据），必须从仓库（HDFS）取原材料（数据块）；加工完的成品（结果）也会存回仓库。
例子：工厂要做蛋糕（计算任务），得先去仓库（HDFS）拿面粉（数据块），做好蛋糕后再放回仓库。
MapReduce和YARN的关系：MapReduce是“加工任务”，YARN是“资源调度中心”。任务要开工（跑Map/Reduce），必须找调度中心申请工人（机器资源）；调度中心根据当前空闲资源，决定任务什么时候、用多少资源开工。
例子：你想在工厂开一条蛋糕流水线（MapReduce任务），得找调度中心（YARN）申请10个工人、5台烤箱（资源），调度中心说“现在有8个工人空闲，先给你8个，剩下2个等半小时”。
HDFS和YARN的关系：HDFS是“仓库管理员”，YARN是“工厂管理员”。仓库管理员（HDFS）要告诉工厂管理员（YARN）：“哪些机器存了数据块（原材料）”，这样YARN调度资源时，可以优先把任务分配到存了数据的机器（减少数据搬运时间）。
例子：仓库管理员说“面粉在3号车间”，工厂管理员就把蛋糕流水线尽量安排在3号车间，避免面粉搬来搬去浪费时间（这就是Hadoop的“计算向数据移动”优化）。

核心概念原理和架构的文本示意图

Hadoop核心架构可总结为“1主多从”的分布式结构：

主节点（Master）：运行NameNode（HDFS总管家）、ResourceManager（YARN总调度员）。
从节点（Slave/Worker）：运行DataNode（HDFS存储数据块）、NodeManager（YARN机器小管家），以及可能的Map/Reduce任务进程。

简单来说：

主节点（Master）
├─ NameNode（管理HDFS元数据）
└─ ResourceManager（管理YARN全局资源）

从节点（Worker）
├─ DataNode（存储HDFS数据块）
├─ NodeManager（监控本机资源，汇报给ResourceManager）
└─ 运行Map/Reduce任务（由ApplicationMaster协调）

组件职责详解

(1) ResourceManager（RM）

全局资源协调者
- 核心模块：
  - ApplicationsManager：应用生命周期管理
  - ResourceScheduler：资源分配决策
- 关键功能：
  - 处理客户端请求
  - 启动 ApplicationMaster
  - 监控节点资源
  - 仲裁应用资源请求

(2) NodeManager（NM）

节点资源管理者

职责矩阵：

功能	描述
资源监控	跟踪节点CPU/内存使用
容器管理	启停容器、资源隔离
健康检查	磁盘健康、节点状态
日志管理	聚合日志到HDFS

关键机制：
- 定期心跳（默认3秒）
- 容器资源隔离（cgroups/Docker）

(3) ApplicationMaster（AM）

应用专属管家

：
- 核心职责：
  - 资源协商（与RM交互）
  - 任务调度（与NM交互）
  - 容错处理（任务重试）
  - 进度监控
- 框架示例：
  - MapReduce：MRAppMaster
  - Spark：SparkAppMaster
  - Flink：FlinkJobManager

(4) Container

资源抽象单元

// 容器资源定义
public class Container {
    private ContainerId containerId;
    private NodeId nodeId;
    private Resource resource; // CPU+内存
    private Priority priority;
    private ContainerState state;
}

资源隔离机制：
- Linux Container（默认）
- Docker Container
- Windows Server Container

Hadoop任务执行流程

te.drawio

核心算法原理 & 具体操作步骤

HDFS：如何保证数据可靠？

HDFS的核心可靠性机制是副本机制和心跳检测。

副本放置策略（默认3副本）

第1个副本：存放在客户端所在机器（如果客户端不在集群中，随机选1台）。
第2个副本：存放在与第1个副本不同的机架（避免整个机架断电）。
第3个副本：存放在与第2个副本同机架，但不同机器。
更多副本：随机存放，但尽量分散机架。

类比：重要文件复印3份，第1份放你家，第2份放隔壁小区（不同机架），第3份放隔壁小区的另一栋楼（同机架不同机器）。

心跳检测（故障恢复）

DataNode每3秒向NameNode发送“心跳”（类似“我还活着”的报告）。
如果超过10分钟没收到心跳（可配置），NameNode认为该DataNode宕机。
此时，NameNode会检查该DataNode上的所有数据块副本数是否不足（比如原本3份，现在只剩2份），并启动“副本复制”：让其他有该数据块的DataNode复制一份到新的DataNode，直到副本数恢复3。

MapReduce：Shuffle阶段的“数据搬运”

MapReduce的核心难点是Shuffle阶段（Map到Reduce的数据传输），它决定了任务的效率。

Shuffle流程（以WordCount为例）

Map输出写入本地磁盘：每个Map任务处理完数据（比如统计单词出现次数），将结果（如<“love”,1>, <“hadoop”,1>）写入本地临时文件。
分区（Partition）：根据Reduce数量，将结果分成多个“区”（比如3个Reduce，就分3区）。分区规则默认是“哈希值%Reduce数量”（比如"love"的哈希%3=0，归第0区；"hadoop"的哈希%3=1，归第1区）。
排序（Sort）：每个分区内的键（如"love"）按字典序排序，方便Reduce合并。
合并（Combine，可选）：如果开启Combine（类似本地小Reduce），会先将同一键的结果相加（如<“love”,1>, <“love”,1>合并为<“love”,2>），减少传输数据量。
Reduce拉取数据：每个Reduce任务从所有Map任务的对应分区（如第0区）拉取数据，合并后排序。
Reduce处理：对排序后的数据，按键分组（如所有"love"的计数），执行Reduce函数（求和），输出最终结果。

类比：班级统计全班同学的姓氏出现次数：

Map阶段：每个小组（Map任务）统计本小组的姓氏次数（如第1组：张3次，李2次；第2组：张1次，王4次）。
Shuffle阶段：按姓氏首字母分区（A-M区、N-Z区），每个小组把A-M区的结果（如张、李）排序后，传给负责A-M区的Reduce同学；N-Z区传给另一个Reduce同学。
Reduce阶段：A-M区的Reduce同学把所有小组的张、李次数相加（张3+1=4，李2=2），输出最终结果。

YARN：如何分配资源？

YARN的资源分配基于容器（Container），每个Container是一组资源（如4GB内存+2个CPU核），任务必须在Container中运行。

YARN任务调度流程

用户提交任务：用户提交MapReduce程序，YARN的ResourceManager收到请求。
启动ApplicationMaster：ResourceManager找一台NodeManager，启动该任务的ApplicationMaster（任务小领导）。
申请资源：ApplicationMaster向ResourceManager申请任务需要的Container（如5个Map Container，2个Reduce Container）。
分配资源：ResourceManager根据集群资源情况（哪些NodeManager有空闲），给ApplicationMaster分配具体的NodeManager和Container。
运行任务：ApplicationMaster通知对应的NodeManager启动Map/Reduce任务进程，任务读取HDFS数据，执行计算。
监控与回收：NodeManager监控Container的资源使用，任务完成后释放Container，资源回到集群池。

类比：公司接了2个项目（任务），总经（ResourceManager）：

给项目A派一个项目经理（ApplicationMaster）。
项目经理找总经理要10个程序员（Container）。
总经理看各部门（NodeManager）的空闲程序员，说“技术部有5个，测试部有3个，先给你8个”。
项目经理让这些程序员去各自部门干活，干完活程序员回到公司池，接下一个项目。

数学模型和公式 & 详细讲解 & 举例说明

大数据怎么存？HDFS：海量数据的分布式文件系统

1. 核心问题：存储瓶颈

一个 1PB 的数据文件你存哪？一台服务器硬盘肯定不够，那就切分文件放到多台机器的硬盘上吧。但这引发了新问题：

数据怎么切？
放哪台机器上？
一台机器宕机了怎么办？

2. HDFS 原理简介

HDFS（Hadoop Distributed File System） 就是为了解决以上问题而生的。

核心机制：

将大文件切分成多个固定大小的数据块（默认 128MB）
分布式存储到多个服务器（DataNode）
每个块做 3 份副本，分散在不同机器，防止数据丢失
有一个主节点（NameNode）记录文件和块之间的映射关系，像文件系统的大脑

类比理解：像把一本书拆成几百页，分别寄给三位朋友，每页都复印几份保管，找一本书就找这些页集合。

[用户/应用]
     ↓
[HDFS NameNode]
     ↓
[多个 DataNode]
 ↙      ↓      ↘
Block1  Block2  Block3（带副本）

用户通过 API 将数据写入 HDFS；

NameNode 管理元数据；

DataNode 负责存放真实的 Block；

每个 Block 会有副本。

3. HDFS存储容量与可靠性公式

假设集群有N台DataNode，每台容量为S GB，副本数为R（默认3），则：

总存储容量 = N × S × (1/R) （因为每个数据块存R份，实际有效数据是总存储的1/R）
例子：100台机器，每台1TB（1000GB），副本数3 → 有效存储=100×1000×(1/3)≈33,333GB=33TB。
数据丢失概率 = (单台机器故障率)^R （假设机器独立故障）
例子：单台机器年故障率1%（0.01），副本数3 → 数据丢失概率=0.01³=0.000001（百万分之一），几乎不可能丢。

大数据怎么算？MapReduce：分而治之的计算模型

1. 核心问题：计算性能瓶颈

我们可能有 1280GB 的订单数据，需要统计每个用户的性别消费金额。直接读取所有数据在一台服务器计算？不存在的，内存都装不下。

2. MapReduce 原理

MapReduce 是一种编程模型，专为大规模数据处理设计，核心思想是“分而治之”：

Map 阶段：每个计算节点处理数据分片，对每条数据执行映射函数
Shuffle 阶段：将 map 阶段结果重新分组（按 key 聚合）
Reduce 阶段：对分组后的数据执行归约操作，得出最终结果

举个例子：

你要统计每种水果卖了多少。Map 把账单拆开成（苹果,1）、（香蕉,1），Reduce 把所有苹果的 1 累加起来得出总量。

[用户/应用]
     ↓
[HDFS]
     ↓
[Map Task] ← 分片数据 Split
     ↓
[Shuffle/Sort]
     ↓
[Reduce Task]
     ↓
[输出结果]

数据先被切成 Split；

Map 处理每一份；

Shuffle 阶段将数据重新分组；

Reduce 汇总结果；

最终输出写回 HDFS 或返回给 Hive 等上层应用。

3. MapReduce任务时间估算

MapReduce任务总时间≈Map时间 + Shuffle时间 + Reduce时间。
其中，Shuffle时间占比最高（50%-70%），主要受网络带宽和数据量影响。
假设Map阶段处理M GB数据，网络带宽B MB/s，Shuffle需传输M GB数据，则：
Shuffle时间 ≈ M×1024 / B 秒
例子：M=100GB，B=100MB/s → 100×1024/100=1024秒≈17分钟。

YARN：让资源调度有序高效

1. 为什么需要 YARN？

Hadoop 集群里跑着成千上万个 MapReduce 任务，任务都需要 CPU、内存等资源。如果没有调度器，大家乱抢资源，整个集群很快就会崩。

2. YARN 原理

YARN（Yet Another Resource Negotiator） 是 Hadoop 的资源调度框架，它做的事情类似 Kubernetes，但更聚焦于大数据场景。

YARN 工作流程：

用户提交任务
YARN 分配容器（运行 Map、Reduce 或 Spark/Flink 任务）
各个任务在对应节点中并行运行
中途出错自动重试或调度其他节点

类比理解：YARN 就像集群的“班主任”，负责把每个学生（任务）分配到不同教室（节点）考试（计算）。

[用户/应用]
     ↓
[提交 MapReduce Job]
     ↓
[YARN ResourceManager]
     ↓（分配资源）
[多个 NodeManager → Container]
     ↓
[Map / Reduce Task 运行中]
     ↓
[结果返回]

YARN 抽象出容器 Container 分配资源；

ResourceManager 决定调度；

NodeManager 执行容器里的计算；

YARN 把 MapReduce 和计算资源隔离开。

项目实战：代码实际案例和详细解释说明

开发环境搭建（以Hadoop 3.3.x为例）

准备3台Linux机器（或用虚拟机模拟），安装Java 8+，配置SSH无密码登录。
下载Hadoop：从官网（https://hadoop.apache.org/）下载hadoop-3.3.x.tar.gz，解压到/xxx/hadoop。
配置核心文件

：
- core-site.xml：指定HDFS的NameNode地址（如hdfs://master:9000）。
- hdfs-site.xml：设置副本数（dfs.replication=3）、数据块大小（dfs.blocksize=134217728=128MB）。
- yarn-site.xml：设置ResourceManager地址（yarn.resourcemanager.hostname=master）。
- mapred-site.xml：指定MapReduce框架为YARN（mapreduce.framework.name=yarn）。
启动集群：
hdfs namenode -format（初始化NameNode）
start-dfs.sh（启动HDFS）
start-yarn.sh（启动YARN）

代码：WordCount（统计文本中单词出现次数）

用Java编写MapReduce程序：

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;
import org.apache.hadoop.util.GenericOptionsParser;

import java.io.IOException;
import java.util.StringTokenizer;

public class ImprovedWordCount {
    
    public static class TokenizerMapper 
        extends Mapper<Object, Text, Text, IntWritable> {
        
        private static final IntWritable ONE = new IntWritable(1);
        private Text word = new Text();
        
        @Override
        public void map(Object key, Text value, Context context)
                throws IOException, InterruptedException {
            
            String line = value.toString().trim();
            if (line.isEmpty()) return;
            
            // 统一转为小写，避免大小写重复计数
            StringTokenizer itr = new StringTokenizer(line.toLowerCase());
            while (itr.hasMoreTokens()) {
                String token = itr.nextToken();
                // 简单的单词清理：移除标点
                token = token.replaceAll("[^a-zA-Z0-9]", "");
                if (!token.isEmpty()) {
                    word.set(token);
                    context.write(word, ONE);
                }
            }
        }
    }
    
    public static class IntSumReducer 
        extends Reducer<Text, IntWritable, Text, IntWritable> {
        
        private IntWritable result = new IntWritable();
        
        @Override
        public void reduce(Text key, Iterable<IntWritable> values, Context context)
                throws IOException, InterruptedException {            
            int sum = 0;
            for (IntWritable val : values) {
                sum += val.get();
            }
            result.set(sum);
            context.write(key, result);
        }
    }
    
    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();        
        // 使用GenericOptionsParser支持更多Hadoop参数
        GenericOptionsParser parser = new GenericOptionsParser(conf, args);
        String[] remainingArgs = parser.getRemainingArgs();        
        if (remainingArgs.length != 2) {
            System.err.println("Usage: ImprovedWordCount <input> <output>");
            System.exit(2);
        }        
        Job job = Job.getInstance(conf, "improved word count");
        job.setJarByClass(ImprovedWordCount.class);        
        // 性能优化：设置合适的reduce数量
        job.setNumReduceTasks(10);
        job.setMapperClass(TokenizerMapper.class);
        job.setCombinerClass(IntSumReducer.class);
        job.setReducerClass(IntSumReducer.class);      
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(IntWritable.class);       
        FileInputFormat.addInputPath(job, new Path(remainingArgs[0]));
        FileOutputFormat.setOutputPath(job, new Path(remainingArgs[1]));   
        // 启用map输出压缩
        conf.set("mapreduce.map.output.compress", "true");
        conf.set("mapreduce.map.output.compress.codec", 
                "org.apache.hadoop.io.compress.SnappyCodec");        
        System.exit(job.waitForCompletion(true) ? 0 : 1);
    }
}

代码解读与分析

Mapper类：TokenizerMapper负责通过.toLowerCase()统一转为小写，避免大小写重复计数，使用replaceAll("[^a-zA-Z0-9]", "")移除非字母数字字符，将输入文本按空格拆分成单词（StringTokenizer），每个单词输出为<单词, 1>（表示该单词出现1次）。
Reducer类：IntSumReducer负责将相同单词的所有计数（如多个<love,1>）相加，输出<love, 总次数>。
Combiner：setCombinerClass(IntSumReducer.class)开启Combine，在Map节点本地先合并计数（如将<love,1>, <love,1>合并为<love,2>），同时用作Combiner，减少shuffle阶段数据传输量。
主函数：配置Job任务，指定输入路径（HDFS中的文本文件）和输出路径（HDFS中的结果目录）。

Hadoop 框架的优势

高容错性：通过数据副本和节点故障自动转移实现
高扩展性：可通过增加节点线性扩展存储和计算能力
低成本：支持普通 x86 服务器，无需专用硬件
适合大数据：高效处理 TB/PB 级数据，远超传统数据库能力
开源生态：拥有丰富的周边工具（Hive、HBase、Spark 等），形成完整数据处理体系

实际应用场景

Hadoop凭借其“海量存储+分布式计算”能力，广泛应用于以下场景：

1. 日志分析（如网站访问日志）

场景：某电商网站每天产生10TB访问日志，需统计“各页面访问量”“用户停留时长”。
Hadoop方案：用HDFS存储日志，MapReduce统计各页面的访问次数（WordCount变种），YARN调度任务资源。

2. 数据仓库：构建企业级数据存储和分析平台

场景：一家大型零售企业需要整合其线上商城、线下门店和供应链系统的数据。这些数据包括结构化的交易记录、半结构化的商品日志和非结构化的客户评价。企业的分析师需要在此基础上，进行跨业务线的综合查询与分析，例如：“计算上季度各区域、各品类的销售额与毛利率”，“追踪热门商品的库存周转情况”。
Hadoop方案：
- HDFS：作为中央数据湖，存储来自各业务系统的原始全量数据（如订单表、商品表、日志文件）。其高容错性和低成本特性，适合长期保存海量的历史数据。
- MapReduce：用于执行复杂的ETL（提取、转换、加载）过程。例如，编写MapReduce任务来清洗和整合不同来源的订单数据，统一数据格式；或通过多阶段计算，生成“用户-商品”关联矩阵等高级聚合指标。
- YARN：作为统一的资源管理器，协调并发的ETL作业、即席查询任务和定期报表生成任务所需的计算资源（CPU、内存），确保这些关键任务能够高效、稳定地运行，互不干扰。

3. 用户行为分析（如推荐系统）

场景：视频平台需分析用户观看记录，找出“喜欢看科幻片的用户”。
Hadoop方案：用HDFS存储用户观看日志（用户ID、视频类型），MapReduce按用户ID分组，统计每个用户的科幻片观看次数，筛选出高频用户。

未来发展挑战

挑战1：小文件问题

HDFS适合存储大文件（128MB+），但小文件（如1KB的日志片段）会占用大量NameNode内存（每个文件需记录元数据）。解决方案：用HDFS的CombineFileInputFormat合并小文件，或使用HBase存储小文件。

挑战2：资源利用率低

YARN的Container资源分配是“静态”的（比如固定4GB内存），但任务可能实际只需2GB，导致资源浪费。未来可能引入“弹性资源分配”（动态调整Container大小）。

开源鸿蒙跨平台开发者社区

开源鸿蒙跨平台开发社区汇聚开发者与厂商，共建“一次开发，多端部署”的开源生态，致力于降低跨端开发门槛，推动万物智联创新。

更多推荐

Linux编译环境从零搭建—【万物智能之开源鸿蒙 OpenHarmony 系统实战开发系列教程】

开源鸿蒙跨平台开发者社区

百元级全开源！海思 WS63 + 开源鸿蒙 + 星闪：小鸿 AI 开发板从零跑通实测

开源鸿蒙跨平台开发者社区

鸿蒙NEXT（五）：鸿蒙版React Native架构浅析

');

开源鸿蒙跨平台开发者社区

所有评论(0)

查看更多评论

m0_65552477

@m0_65552477

已为社区贡献1条内容

大数据时代：Hadoop架构及其组件详解

m0_65552477

大数据时代：Hadoop架构及其组件详解

术语表

核心术语定义

相关概念解释

为什么需要 Hadoop？

设计原则

核心概念与联系

故事引入：从“图书馆管书”到“工厂加工书”

核心概念解释

核心概念一：HDFS——分布式文件系统（分书架存书）

核心概念二：MapReduce——分布式计算模型（流水线加工）

核心概念三：YARN——资源管理框架（调度员管工人）

核心概念之间的关系

核心概念原理和架构的文本示意图

组件职责详解

(1) ResourceManager（RM）

(2) NodeManager（NM）

(3) ApplicationMaster（AM）

(4) Container

Hadoop任务执行流程

核心算法原理 & 具体操作步骤

HDFS：如何保证数据可靠？

副本放置策略（默认3副本）

心跳检测（故障恢复）

MapReduce：Shuffle阶段的“数据搬运”

Shuffle流程（以WordCount为例）

YARN：如何分配资源？

YARN任务调度流程

数学模型和公式 & 详细讲解 & 举例说明

大数据怎么存？HDFS：海量数据的分布式文件系统

1. 核心问题：存储瓶颈

2. HDFS 原理简介

3. HDFS存储容量与可靠性公式

大数据怎么算？MapReduce：分而治之的计算模型

1. 核心问题：计算性能瓶颈

2. MapReduce 原理

3. MapReduce任务时间估算

YARN：让资源调度有序高效

1. 为什么需要 YARN？

2. YARN 原理

项目实战：代码实际案例和详细解释说明

开发环境搭建（以Hadoop 3.3.x为例）

代码：WordCount（统计文本中单词出现次数）

代码解读与分析

Hadoop 框架的优势

实际应用场景

1. 日志分析（如网站访问日志）

2. 数据仓库：构建企业级数据存储和分析平台

3. 用户行为分析（如推荐系统）

未来发展挑战

挑战1：小文件问题

挑战2：资源利用率低

所有评论(0)

温馨提示：您尚未绑定手机号

m0_65552477