顶部
收藏

分布式计算系统


作者:
徐辰
定价:
46.60 元
版面字数:
490.00千字
开本:
16开
装帧形式:
平装
页数:
324
最新
印次时间:
2026年01月
ISBN:
978-7-04-058450-9
物料号:
58450-00
出版时间:
2022-09-19
读者对象:
高等教育
一级分类:
计算机/教育技术类
二级分类:
计算机科学与技术专业课程

本书是“十四五”普通高等教育本科国家级规划教材,同时是大数据新兴领域“十四五”高等教育教材。本书聚焦于Hadoop、Spark、Flink等面向数据密集型应用的分布式计算系统,将原理、架构、编程的知识进行有机结合,统一从设计思想、体系架构、工作原理、容错机制和编程示例5个维度进行剖析。本书注重通过横向比较阐释该类系统设计的共性原理,帮助读者形成完整、统一的知识体系。 本书概述了分布式计算系统(第1章),根据应用场景的差异将分布式计算系统划分为批处理系统(第3、4章)、流计算系统(第7、8章)、批流融合系统(第9、10章)、图处理系统(第11章),并选取了各个类别中的典型代表。由于这些分布式计算系统不可能孤立地存在,因此本书也介绍了面向文件存储(第2章)、资源管理(第5章)以及协调服务(第6章)的系统。 本书可作为高等院校数据科学与大数据技术专业高年级本科生的教学用书,以及计算机科学与技术、软件工程、数据科学与工程等专业研究生的教学用书,也可作为部分业界研发人员的参考用书。
  • 目录
    • 前辅文
      • 第1章 绪论
        • 1.1 分布式系统
          • 1.1.1 分布式系统的概念
            • 1.1.2 分布式系统的类型
            • 1.2 从数据管理角度看分布式系统
              • 1.2.1 数据管理系统的发展历程
                • 1.2.2 大数据背景下数据管理面临的挑战
                  • 1.2.3 面向数据管理的分布式系统
                  • 1.3 分布式计算系统
                    • 1.3.1 分布式计算系统的概念
                      • 1.3.2 系统生态圈
                      • 1.4 本书组织结构
                        • 本章小结
                          • 习题1
                          • 第2章 Hadoop文件系统
                            • 2.1 设计思想
                              • 2.2 体系架构
                                • 2.2.1 架构图
                                  • 2.2.2 应用程序执行流程
                                  • 2.3 工作原理
                                    • 2.3.1 文件分块与备份
                                      • 2.3.2 文件写入
                                        • 2.3.3 文件读取
                                          • 2.3.4 文件读写与一致性
                                          • 2.4 容错机制
                                            • 2.4.1 NameNode故障
                                              • 2.4.2 DataNode故障
                                              • 2.5 编程示例
                                                • 2.5.1 写文件
                                                  • 2.5.2 读文件
                                                  • 本章小结
                                                    • 习题2
                                                    • 第3章 批处理系统MapReduce
                                                      • 3.1 设计思想
                                                        • 3.1.1 MPI与MapReduce
                                                          • 3.1.2 数据模型
                                                            • 3.1.3 计算模型
                                                            • 3.2 体系架构
                                                              • 3.2.1 架构图
                                                                • 3.2.2 应用程序执行流程
                                                                • 3.3 工作原理
                                                                  • 3.3.1 数据输入
                                                                    • 3.3.2 Map阶段
                                                                      • 3.3.3 Shuffle阶段
                                                                        • 3.3.4 Reduce阶段
                                                                          • 3.3.5 数据输出
                                                                          • 3.4 容错机制
                                                                            • 3.4.1 JobTracker故障
                                                                              • 3.4.2 TaskTracker故障
                                                                                • 3.4.3 Task故障
                                                                                • 3.5 编程示例
                                                                                  • 3.5.1 词频统计
                                                                                    • 3.5.2 关系表自然连接及其优化
                                                                                      • 3.5.3 网页链接排名
                                                                                        • 3.5.4 K均值聚类
                                                                                        • 本章小结
                                                                                          • 习题3
                                                                                          • 第4章 批处理系统Spark
                                                                                            • 4.1 设计思想
                                                                                              • 4.1.1 MapReduce的局限性
                                                                                                • 4.1.2 数据模型
                                                                                                  • 4.1.3 计算模型
                                                                                                  • 4.2 体系架构
                                                                                                    • 4.2.1 架构图
                                                                                                      • 4.2.2 应用程序执行流程
                                                                                                      • 4.3 工作原理
                                                                                                        • 4.3.1 Stage划分
                                                                                                          • 4.3.2 Stage内部的数据传输
                                                                                                            • 4.3.3 Stage之间的数据传输
                                                                                                              • 4.3.4 应用与作业
                                                                                                              • 4.4 容错机制
                                                                                                                • 4.4.1 RDD持久化
                                                                                                                  • 4.4.2 故障恢复
                                                                                                                    • 4.4.3 检查点
                                                                                                                    • 4.5 编程示例
                                                                                                                      • 4.5.1 词频统计
                                                                                                                        • 4.5.2 关系表自然连接及其优化
                                                                                                                          • 4.5.3 网页链接排名
                                                                                                                            • 4.5.4 K均值聚类
                                                                                                                              • 4.5.5 检查点
                                                                                                                              • 本章小结
                                                                                                                                • 习题4
                                                                                                                                • 第5章 资源管理系统Yarn
                                                                                                                                  • 5.1 设计思想
                                                                                                                                    • 5.1.1 作业与资源管理
                                                                                                                                      • 5.1.2 平台与框架
                                                                                                                                      • 5.2 体系架构
                                                                                                                                        • 5.2.1 架构图
                                                                                                                                          • 5.2.2 应用程序执行流程
                                                                                                                                          • 5.3 工作原理
                                                                                                                                            • 5.3.1 单平台多框架
                                                                                                                                              • 5.3.2 平台资源分配
                                                                                                                                              • 5.4 容错机制
                                                                                                                                                • 5.5 典型示例
                                                                                                                                                  • 5.5.1 Yarn平台运行MapReduce框架
                                                                                                                                                    • 5.5.2 Yarn平台运行Spark框架
                                                                                                                                                      • 5.5.3 Yarn平台运行MapReduce和Spark框架
                                                                                                                                                      • 本章小结
                                                                                                                                                        • 习题5
                                                                                                                                                        • *第6章 协调服务系统ZooKeeper
                                                                                                                                                          • 6.1 设计思想
                                                                                                                                                            • 6.1.1 数据模型
                                                                                                                                                              • 6.1.2 操作原语
                                                                                                                                                              • 6.2 体系架构
                                                                                                                                                                • 6.3 工作原理
                                                                                                                                                                  • 6.3.1 领导者选举
                                                                                                                                                                    • 6.3.2 读写请求流程
                                                                                                                                                                    • 6.4 容错机制
                                                                                                                                                                      • 6.5 典型示例
                                                                                                                                                                        • 6.5.1 命名服务
                                                                                                                                                                          • 6.5.2 集群管理
                                                                                                                                                                            • 6.5.3 配置更新
                                                                                                                                                                              • 6.5.4 同步控制
                                                                                                                                                                              • 本章小结
                                                                                                                                                                                • 习题6
                                                                                                                                                                                • *第7章 流计算系统Storm
                                                                                                                                                                                  • 7.1 设计思想
                                                                                                                                                                                    • 7.1.1 连续处理
                                                                                                                                                                                      • 7.1.2 数据模型
                                                                                                                                                                                        • 7.1.3 计算模型
                                                                                                                                                                                        • 7.2 体系架构
                                                                                                                                                                                          • 7.2.1 架构图
                                                                                                                                                                                            • 7.2.2 应用程序执行流程
                                                                                                                                                                                            • 7.3 工作原理
                                                                                                                                                                                              • 7.3.1 流数据分组策略
                                                                                                                                                                                                • 7.3.2 元组传递方式
                                                                                                                                                                                                • 7.4 容错机制
                                                                                                                                                                                                  • 7.4.1 容错语义
                                                                                                                                                                                                    • 7.4.2 元组树
                                                                                                                                                                                                      • 7.4.3 ACK机制
                                                                                                                                                                                                        • 7.4.4 消息重放
                                                                                                                                                                                                        • 7.5 编程示例
                                                                                                                                                                                                          • 7.5.1 词频统计
                                                                                                                                                                                                            • 7.5.2 支持容错的词频统计
                                                                                                                                                                                                              • 7.5.3 简化的窗口操作
                                                                                                                                                                                                                • 7.5.4 异常检测
                                                                                                                                                                                                                • 本章小结
                                                                                                                                                                                                                  • 习题7
                                                                                                                                                                                                                  • *第8章 流计算系统Spark Streaming
                                                                                                                                                                                                                    • 8.1 设计思想
                                                                                                                                                                                                                      • 8.1.1 微批处理
                                                                                                                                                                                                                        • 8.1.2 数据模型
                                                                                                                                                                                                                          • 8.1.3 计算模型
                                                                                                                                                                                                                          • 8.2 体系架构
                                                                                                                                                                                                                            • 8.2.1 架构图
                                                                                                                                                                                                                              • 8.2.2 应用程序执行流程
                                                                                                                                                                                                                              • 8.3 工作原理
                                                                                                                                                                                                                                • 8.3.1 数据输入
                                                                                                                                                                                                                                  • 8.3.2 数据转换
                                                                                                                                                                                                                                    • 8.3.3 数据输出
                                                                                                                                                                                                                                    • 8.4 容错机制
                                                                                                                                                                                                                                      • 8.4.1 基于RDD Lineage的容错
                                                                                                                                                                                                                                        • 8.4.2 基于日志的容错
                                                                                                                                                                                                                                          • 8.4.3 基于检查点的容错
                                                                                                                                                                                                                                            • 8.4.4 端到端的容错语义
                                                                                                                                                                                                                                            • 8.5 编程示例
                                                                                                                                                                                                                                              • 8.5.1 按批词频统计
                                                                                                                                                                                                                                                • 8.5.2 全局词频统计
                                                                                                                                                                                                                                                  • 8.5.3 窗口操作
                                                                                                                                                                                                                                                    • 8.5.4 异常检测
                                                                                                                                                                                                                                                    • 本章小结
                                                                                                                                                                                                                                                      • 习题8
                                                                                                                                                                                                                                                      • *第9章 批流融合基础
                                                                                                                                                                                                                                                        • 9.1 批流融合的背景
                                                                                                                                                                                                                                                          • 9.1.1 应用需求
                                                                                                                                                                                                                                                            • 9.1.2 Lambda架构及其局限性
                                                                                                                                                                                                                                                            • 9.2 批处理与流计算的统一性
                                                                                                                                                                                                                                                              • 9.2.1 有界数据集与无界数据集
                                                                                                                                                                                                                                                                • 9.2.2 窗口操作
                                                                                                                                                                                                                                                                  • 9.2.3 时间域
                                                                                                                                                                                                                                                                  • 9.3 Dataflow统一编程模型
                                                                                                                                                                                                                                                                    • 9.3.1 操作描述
                                                                                                                                                                                                                                                                      • 9.3.2 窗口定义
                                                                                                                                                                                                                                                                        • 9.3.3 触发器
                                                                                                                                                                                                                                                                          • 9.3.4 结果修正
                                                                                                                                                                                                                                                                          • 9.4 关系化Dataflow编程模型
                                                                                                                                                                                                                                                                            • 9.5 一体化执行引擎
                                                                                                                                                                                                                                                                              • 9.5.1 以批处理为核心
                                                                                                                                                                                                                                                                                • 9.5.2 以流计算为核心
                                                                                                                                                                                                                                                                                • 本章小结
                                                                                                                                                                                                                                                                                  • 习题9
                                                                                                                                                                                                                                                                                  • 第10章 批流融合系统Flink
                                                                                                                                                                                                                                                                                    • 10.1 设计思想
                                                                                                                                                                                                                                                                                      • 10.1.1 数据模型
                                                                                                                                                                                                                                                                                        • 10.1.2 计算模型
                                                                                                                                                                                                                                                                                          • 10.1.3 迭代模型
                                                                                                                                                                                                                                                                                          • 10.2 体系架构
                                                                                                                                                                                                                                                                                            • 10.2.1 架构图
                                                                                                                                                                                                                                                                                              • 10.2.2 应用程序执行流程
                                                                                                                                                                                                                                                                                              • 10.3 工作原理
                                                                                                                                                                                                                                                                                                • 10.3.1 逻辑执行图的生成与优化
                                                                                                                                                                                                                                                                                                  • 10.3.2 物理执行图的生成与任务分配
                                                                                                                                                                                                                                                                                                    • 10.3.3 非迭代任务间的数据传输
                                                                                                                                                                                                                                                                                                      • 10.3.4 迭代任务间的数据传输
                                                                                                                                                                                                                                                                                                        • *10.3.5 Dataflow编程模型的实现
                                                                                                                                                                                                                                                                                                          • *10.3.6 关系化Dataflow编程模型的实现
                                                                                                                                                                                                                                                                                                          • 10.4 容错机制
                                                                                                                                                                                                                                                                                                            • 10.4.1 状态管理
                                                                                                                                                                                                                                                                                                              • 10.4.2 非迭代计算过程的容错
                                                                                                                                                                                                                                                                                                                • 10.4.3 迭代计算过程的容错
                                                                                                                                                                                                                                                                                                                • 10.5 编程示例
                                                                                                                                                                                                                                                                                                                  • 10.5.1 词频统计
                                                                                                                                                                                                                                                                                                                    • 10.5.2 斐波那契数列生成
                                                                                                                                                                                                                                                                                                                      • *10.5.3 整数求和
                                                                                                                                                                                                                                                                                                                        • 10.5.4 支持容错的词频统计
                                                                                                                                                                                                                                                                                                                        • 本章小结
                                                                                                                                                                                                                                                                                                                          • 习题10
                                                                                                                                                                                                                                                                                                                          • *第11章 图处理系统Giraph
                                                                                                                                                                                                                                                                                                                            • 11.1 设计思想
                                                                                                                                                                                                                                                                                                                              • 11.1.1 数据模型
                                                                                                                                                                                                                                                                                                                                • 11.1.2 计算模型
                                                                                                                                                                                                                                                                                                                                  • 11.1.3 迭代模型
                                                                                                                                                                                                                                                                                                                                  • 11.2 体系架构
                                                                                                                                                                                                                                                                                                                                    • 11.2.1 架构图
                                                                                                                                                                                                                                                                                                                                      • 11.2.2 应用程序执行流程
                                                                                                                                                                                                                                                                                                                                      • 11.3 工作原理
                                                                                                                                                                                                                                                                                                                                        • 11.3.1 数据划分
                                                                                                                                                                                                                                                                                                                                          • 11.3.2 超步计算
                                                                                                                                                                                                                                                                                                                                            • 11.3.3 同步控制
                                                                                                                                                                                                                                                                                                                                            • 11.4 容错机制
                                                                                                                                                                                                                                                                                                                                              • 11.4.1 检查点
                                                                                                                                                                                                                                                                                                                                                • 11.4.2 故障恢复
                                                                                                                                                                                                                                                                                                                                                • 11.5 编程示例
                                                                                                                                                                                                                                                                                                                                                  • 11.5.1 连通分量
                                                                                                                                                                                                                                                                                                                                                    • 11.5.2 单源最短路径
                                                                                                                                                                                                                                                                                                                                                      • 11.5.3 网页链接排名
                                                                                                                                                                                                                                                                                                                                                        • 11.5.4 K均值聚类
                                                                                                                                                                                                                                                                                                                                                        • 本章小结
                                                                                                                                                                                                                                                                                                                                                          • 习题11
                                                                                                                                                                                                                                                                                                                                                          • 参考文献

                                                                                                                                                                                                                                                                                                                                                          相关图书