Spark第一天学习

Spark第一天学习

    Spark介绍

        简介：Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎。 Spark 是加州大学伯克利分校的

AMP实验室所开源的类 Hadoop MapReduce 的通用并行计算框架， Spark 拥有 Hadoop MapReduce 所具

有的优点；但不同于 MapReduce 的是 Job 中间输出结果可以缓存在内存中，从而不再需要读写 HDFS ，

减少磁盘数据交互，因此 Spark 能更好地适用于数据挖掘与机器学习等需要迭代的算法。

Spark 是 Scala 编写，方便快速编程。

        总体技术栈的描述

            

            

        Spark 提供了 Sparkcore RDD 、 Spark SQL 、 Spark Streaming 、 Spark MLlib 、 Spark GraphX

等技术组件，可以一站式地完成大数据领域的离线批处理、交互式查询、流式计算、机器学习、图计算

等常见的任务。这就是 spark 一站式开发的特点。

        Spark与MR的区别

            最主要的区别还是执行的流程

                MapReduce执行流程

                    

                Spark的执行流程

                    

            都是分布式计算框架， Spark 计算中间结果基于内存缓存， MapReduce 基于 HDFS 存储。也正因此，

Spark 处理数据的能力一般是 MR 的三到五倍以上， Spark 中除了基于内存计算这一个计算快的原因，

还有 DAG（DAGShecdule） 有向无环图来切分任务的执行先后顺序。

    SparkCore

        概念：Spark RDD 是一种分布式的数据集，由于数据量很大，因此要它被切分并存储在各个结点的分区当中。

Spark中，RDD（Resilient Distributed Dataset）是其最基本的抽象数据集，其中每个RDD是由若干个Partition组成。

RDD1包含了5个Partition，RDD2包含了3个Partition，这些Partition分布在4个节点中。

            

        分区方式

            Spark包含两种数据分区方式：HashPartitioner（哈希分区）和RangePartitioner（范围分区）。

在Spark Shuffle阶段中，共分为Shuffle Write阶段和Shuffle Read阶段，其中在Shuffle Write阶段中，Shuffle Map Task对数据进行处理产生中间数据，然后再根据数据分区方式对中间数据进行分区。最终Shffle Read阶段中的Shuffle Read Task会拉取Shuffle Write阶段中产生的并已经分好区的中间数据。

                

            HashPartitioner

                Hash分区

HashPartitioner采用哈希的方式对<Key，Value>键值对数据进行分区。

其数据分区规则为 partitionId = Key.hashCode % numPartitions

partitionId代表该Key对应的键值对数据应当分配到的Partition标识

Key.hashCode表示该Key的哈希值

numPartitions表示包含的Partition个数。

            RangePartitioner

                范围分区

Spark引入RangePartitioner的目的是为了解决HashPartitioner所带来的分区倾斜问题，也即分区中包含的数据量不均衡问题。

HashPartitioner采用哈希的方式将同一类型的Key分配到同一个Partition中，当某几种类型数据量较多时，就会造成若干Partition中包含的数据过大

在Job执行过程中，一个Partition对应一个Task，此时就会使得某几个Task运行过慢。

RangePartitioner基于抽样的思想来对数据进行分区

                    

        HDFS与Partition

            hdfs中的block是分布式存储的最小单元，类似于盛放文件的盒子，一个文件可能要占多个盒子，

但一个盒子里的内容只可能来自同一份文件。假设block设置为128M，你的文件是260M，那么这份文件占3个block（128+128+4）。这样的设计虽然会有一部分磁盘空间的浪费，但是整齐的block大小，便于快速找到、读取对应的内容。（p.s. 考虑到hdfs冗余设计，默认三份拷贝，实际上3*3=9个block的物理空间。）

            spark中的partition 是弹性分布式数据集RDD的最小单元，RDD是由分布在各个节点上的partition

组成的。partition 是指的spark在计算过程中，生成的数据在计算空间内最小单元，同一份数据

（RDD）的partition 大小不一，数量不定，是根据application里的算子和最初读入的数据分块数量决定的

            block位于存储空间、partition 位于计算空间，

block的大小是固定的、partition 大小是不固定的，

block是有冗余的、不会轻易丢失，partition（RDD）没有冗余设计、丢失之后重新计算得到.

            Spark从HDFS读入文件的分区数默认等于HDFS文件的块数(blocks)，HDFS中的block是分布式存储

的最小单元。如果我们上传一个30GB的非压缩的文件到HDFS，HDFS默认的块容量大小128MB，因此该文件在HDFS上会被分为235块(30GB/128MB)；Spark取SparkContext.textFile()读取该文件，默认分区数等于块数即235。

    RDD

        RDD(Resilient Distributed Dataset) 弹性分布式数据集。

        RDD五大属性

            A list of partitions

RDD 是由一系列的 partition 组成的。

            A function for computing each split

函数是作用在每一个 partition/split 上。

            A list of dependencies on other RDDs

RDD 之间有一系列的依赖关系。

            Optionally, a Partitioner for key-value RDDs

分区器是作用在 (K,V) 格式的 RDD 上。

            Optionally, a list of preferred locations to compute each split on

RDD 提供一系列最佳的计算位置。

        注意

            textFile 方法底层封装的是 MR 读取文件的方式，读取文件之前先进行 split 切片，默认 split

大小是一个 block 大小。

RDD 实际上不存储数据，这里方便理解，暂时理解为存储数据。

什么是 K,V格式的RDD ?

如果 RDD 里面存储的数据都是二元组对象，那么这个 RDD 我们就叫做 K,V格式的RDD 。

哪里体现 RDD 的弹性（容错）？

partition 数量，大小没有限制，体现了 RDD 的弹性。

RDD 之间依赖关系，可以基于上一个 RDD 重新计算出 RDD 。

哪里体现 RDD 的分布式？

RDD 是由 Partition 组成， partition 是分布在不同节点上的。

RDD 提供计算最佳位置，体现了数据本地化。体现了大数据中“计算移动数据不移动”的理念。

                

        Lineage血统

            RDD 的最重要的特性之一就是血缘关系（Lineage )，它描述了一个 RDD 是如何从父 RDD 计算得

来的。如果某个 RDD 丢失了，则可以根据血缘关系，从父 RDD 计算得来。

            简单说就是根据子类坏了，通过它的父类，把该子类的数据在此拿到

    算子（多文件）

        转换算子

            转换算组join

                leftOuterJoin

rightOuterJoin

fullOuterJoin

这些 join 都是作用在 K,V 格式的 RDD 上。根据 key 值进行连接，例如： (K,V)join(K,W)返

回(K,(V,W))

注意： join 后的分区数与父RDD分区数多的那一个相同。

            union

                合并两个数据集，两个数据集的类型需要一样

                返回新的RDD的分区数是合并RDD分区数的总和

            intersection

                取两个数据集的交集

            subtract

                取两个数据集的差集

            mapPartitions

                mapPartition与 map 类似，单位是每个 partition 上的数据。

            distinct(map+reduceByKey+map)

                对RDD内数据去重

            cogroup

                当调用类型 (K,V) 和 (K，W) 的数据上时，返回一个数据集 (K，

(Iterable<V>,Iterable<W>)) 。

        行动算子

            foreachPartition

遍历的数据是每个 partition 的数据。

    算子（单文件）

        Spark 记录了 RDD 之间的生成和依赖关系。但是只有当 F 进行行动操作时，Spark 才会根据 RDD

的依赖关系生成 DAG，并从起点开始真正的计算。

            

        转换算子

            概念：Transformations 类算子叫做转换算子（本质就是函数）， Transformations 算子是延迟执行，也叫懒加载执行。

            常见Transformation类算子

                filter ：过滤符合条件的记录数， true 保留， false 过滤掉。

map ：将一个 RDD 中的每个数据项，通过 map 中的函数映射变为一个新的元素。特点：输入一条，输出一条数据。

flatMap ：先 map 后 flat 。与 map 类似，每个输入项可以映射为0到多个输出项。

sample 随机抽样算子，根据传进去的小数按比例进行有放回或者无放回的抽样。

reduceByKey 将相同的 Key 根据相应的逻辑进行处理。

sortByKey / sortBy 作用在 K,V格式的RDD 上，对 key 进行升序或者降序排序。

        行动算子

            概念

Action 类算子叫做行动算子， Action 类算子是触发执行。

一个 application 应用程序中有几个 Action 类算子执行，就有几个 job 运行。

            常见 Action 类算子

count ：返回数据集中的元素数。会在结果计算完成后回收到 Driver 端。

take(n) ：返回一个包含数据集前 n 个元素的集合。

first ：效果等同于 take(1) ,返回数据集中的第一个元素。

foreach ：循环遍历数据集中的每个元素，运行相应的逻辑。

collect ：将计算结果回收到 Driver 端。

        控制算子

            概念

将 RDD 持久化，持久化的单位是 partition 。

控制算子有三种， cache , persist , checkpoint 。 cache 和 persist 都是懒执行的。必须有一个 action 类算子触发执行。

checkpoint 算子不仅能将 RDD 持久化到磁盘，还能切断 RDD 之间的依赖关系。

        cache

            默认将 RDD 的数据持久化到内存中。 cache 是懒执行。

cache() = persist() = persist(StorageLevel.Memory_Only)

rdd.cache().count() 返回的不是持久化的RDD，而是一个数值

        persist

            可以指定持久化的级别。最常用的是 MEMORY_ONLY 和 MEMORY_AND_DISK 。

        checkpoint

            checkpoint 将 RDD 持久化到磁盘，还可以切断 RDD 之间的依赖关系，也是懒执行。

            执行原理

                当 RDD 的 job 执行完毕后，会从 finalRDD 从后往前回溯。

当回溯到某一个 RDD 调用了 checkpoint 方法，会对当前的 RDD 做一个标记。

Spark 框架会自动启动一个新的 job ，重新计算这个 RDD 的数据，将数据持久化到Checkpint目录中。

            使用 checkpoint 时常用优化手段

                对 RDD 执行 checkpoint 之前，最好对这个 RDD 先执行 cache

这样新启动的 job 只需要将内存中的数据拷贝到Checkpint目录中就可以，省去了重新计算这一步。

    系统架构

        Master ( standalone 模式)：资源管理的主节点（进程）。

Cluster Manager ：在集群上获取资源的外部服务（例如： standalone ； yarn ； mesos ）。

Worker ( standalone 模式）：资源管理的从节点（进程）或者说是是管理本机资源的进程。

Application ：基于 Spark 的用户程序，包含 driver 程序和运行在集群上的 executor 程序，即一个完整的 spark 应用 。

Dirver （ program ）：用来连接工作进程（ worker ）的程序 。

Executor ：是在一个 worker 进程所管理的节点上为某 Application 启动的一个个进程，这个进

程负责运行任务，并且负责将数据存在内存或者磁盘上，每个应用之间都有各自独立的executors 。

Task ：被发送到 executor 上的工作单元。

Job ：包含很多任务（ Task ）的并行计算，和 action 算子对应。

Stage ：一个 job 会被拆分成很多组任务，每组任务被称为 Stage （就像 MapReduce 分为MapTask 和 ReduceTask 一样）。