Spark核心编程

基本介绍

Spark 计算框架为了能够进行高并发和高吞吐的数据处理,封装了三大数据结构,用于处理不同的应用场景。三大数据结构分别是:

  • RDD : 弹性分布式数据集
  • 累加器:分布式共享只写变量
  • 广播变量:分布式共享只读变量

RDD

RDD基本介绍

RDD(Resilient Distributed Dataset)叫做弹性分布式数据集,是Spark 中最基本的数据处理模型。代码中是一个抽象类,它代表一个弹性的、不可变、可分区、里面的元素可并行计算的集合。
(1)弹性

  • 存储的弹性:内存与磁盘的自动切换;
  • 容错的弹性:数据丢失可以自动恢复;
  • 计算的弹性:计算出错重试机制;
  • 分片的弹性:可根据需要重新分片。

(2) 分布式:数据存储在大数据集群不同节点上
(3) 数据集:RDD 封装了计算逻辑,并不保存数据
(4)数据抽象:RDD 是一个抽象类,需要子类具体实现
(5)不可变:RDD 封装了计算逻辑,是不可以改变的,想要改变,只能产生新的RDD,在
新的RDD 里面封装计算逻辑
(6)可分区、并行计算

核心属性

/**
 *	Internally, each RDD is characterized by five main properties:
 *
 *  - A list of partitions
 *  - A function for computing each split
 *  - A list of dependencies on other RDDs
 *  - Optionally, a Partitioner for key-value RDDs (e.g. to say that the RDD is hash-partitioned)
 *  - Optionally, a list of preferred locations to compute each split on (e.g. block locations for
 *    an HDFS file)
 * /

(1)分区列表
RDD 数据结构中存在分区列表,用于执行任务时并行计算,是实现分布式计算的重要性。

/**
   * Implemented by subclasses to return the set of partitions in this RDD. This method will only
   * be called once, so it is safe to implement a time-consuming computation in it.
   *
   * The partitions in this array must satisfy the following property:
   *   `rdd.partitions.zipWithIndex.forall { case (partition, index) => partition.index == index }`
   */
  protected def getPartitions: Array[Partition]

(2)分区计算函数
Spark 在计算时,是使用分区函数对每一个分区进行计算。

/**
   * :: DeveloperApi ::
   * Implemented by subclasses to compute a given partition.
   */
  @DeveloperApi
  def compute(split: Partition, context: TaskContext): Iterator[T]

(3) RDD 之间的依赖关系
RDD 是计算模型的封装,当需求中需要将多个计算模型进行组合时,就需要将多个 RDD 建
立依赖关系

  /**
   * Implemented by subclasses to return how this RDD depends on parent RDDs. This method will only
   * be called once, so it is safe to implement a time-consuming computation in it.
   */
  protected def getDependencies: Seq[Dependency[_]] = deps

(4)分区器(可选)

当数据为KV 类型数据时,可以通过设定分区器自定义数据的分区。

  /** Optionally overridden by subclasses to specify how they are partitioned. */
  @transient val partitioner: Option[Partitioner] = None

(5)首选位置(可选)
计算数据时,可以根据计算节点的状态选择不同的节点位置进行计算。

/**
   * Optionally overridden by subclasses to specify placement preferences.
   */
  protected def getPreferredLocations(split: Partition): Seq[String] = Nil

执行原理

从计算的角度来讲,数据处理过程中需要计算资源(内存 & CPU)和计算模型(逻辑)。执行时,需要将计算资源和计算模型进行协调和整合。
Spark 框架在执行时,先申请资源,然后将应用程序的数据处理逻辑分解成一个一个的计算任务。然后将任务发到已经分配资源的计算节点上, 按照指定的计算模型进行数据计算。最后得到计算结果。
RDD 是Spark 框架中用于数据处理的核心模型,在Yarn 环境中,RDD的工作原理:
(1)启动Yarn 集群环境
在这里插入图片描述
(2) Spark 通过申请资源创建调度节点和计算节点
在这里插入图片描述
(3)Spark 框架根据需求将计算逻辑根据分区划分成不同的任务
在这里插入图片描述
(4)调度节点将任务根据计算节点状态发送到对应的计算节点进行计算
在这里插入图片描述
从以上流程可以看出 RDD 在整个流程中主要用于将逻辑进行封装,并生成Task 发送给
Executor 节点执行计算。

基础编程

RDD创建

在Spark 中创建RDD 的创建方式可以分为四种:
(1)从集合(内存)中创建 RDD
从集合中创建RDD,Spark 主要提供了两个方法:parallelize ()和makeRDD()

package com.atguigu.bigdata.spark.core.rdd.builder

import org.apache.spark.rdd.RDD
import org.apache.spark.{
    
    SparkConf, SparkContext}

object Spark01_RDD_Memory {
    
    

  def main(args: Array[String]): Unit = {
    
    

    //TODO 准备环境
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc = new SparkContext(sparkConf)

    //TODO 创建RDD
    //从内存中创建:将内存中集合的数据作为处理的数据源
    val seq = Seq[Int](1,2,3,4)

    //parallelize:并行
//    val rdd: RDD[Int] = sc.parallelize(seq)

    //另外一个方法makeRDD():在底层实现时候其实就是调用了rdd对象的paralleliz方法
    val rdd: RDD[Int] = sc.makeRDD(seq)

    rdd.collect().foreach(println)

    //TODO 关闭环境
    sc.stop()
  }

}

从底层代码实现来讲,makeRDD() 方法其实就是parallelize() 方法。底层代码如下:

def makeRDD[T: ClassTag]( 
    seq: Seq[T], 
    numSlices: Int = defaultParallelism): RDD[T] = withScope {
    
     
  parallelize(seq, numSlices) 
} 

(2) 从外部存储(文件)创建RDD
由外部存储系统的数据集创建RDD 包括:本地的文件系统,所有Hadoop 支持的数据集,比如HDFS、HBase 等。

package com.atguigu.bigdata.spark.core.rdd.builder

import org.apache.spark.rdd.RDD
import org.apache.spark.{
    
    SparkConf, SparkContext}

object Spark02_RDD_File {
    
    

  def main(args: Array[String]): Unit = {
    
    

    //TODO 准备环境
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    val sc = new SparkContext(sparkConf)

    //TODO 创建RDD
    //从内存中创建:将文件中的数据作为处理的数据源
    //path路径默认以当前环境的根路径为基准,可以写绝对路径,也可以写相对路径
//    val rdd: RDD[String] = sc.textFile("datas/1.txt")   //相对路径

    //path路径可以是文件的具体路径,也可以是目录
//    val rdd: RDD[String] = sc.textFile("datas") //统计目录中所有文件

    //path路径还可以使用通配符
    val rdd: RDD[String] = sc.textFile("datas/1*.txt")

    //path路径还可以是分布式存储系统路径:HDFS


    rdd.collect().foreach(println)

    //TODO 关闭环境
    sc.stop()
  }

}

(3)从其他RDD结果创建
主要是通过一个RDD 运算完后,再产生新的RDD。
(4)直接创建RDD(new)

RDD 并行度与分区

默认情况下,Spark 可以将一个作业切分多个任务后,发送给Executor 节点并行计算,而能
够并行计算的任务数量我们称之为并行度。这个数量可以在构建RDD 时指定。
注意:这里的并行执行的任务数量,并不是指的切分任务的数量。

package com.atguigu.bigdata.spark.core.rdd.builder

import org.apache.spark.rdd.RDD
import org.apache.spark.{
    
    SparkConf, SparkContext}

object Spark01_RDD_Memory_Par {
    
    

  def main(args: Array[String]): Unit = {
    
    

    //TODO 准备环境
    val sparkConf: SparkConf = new SparkConf().setMaster("local[*]").setAppName("RDD")
    sparkConf.set("spark.default.parallelism","4") //也可以配
    val sc = new SparkContext(sparkConf)


    //TODO 创建RDD
    //RDD的并行度 & 分区
    //makeRDD可以传第二个参数,第二个参数表示分区数
    //第二个参数可以不传递,不传的话,使用默认值:defaultParallelism(默认并行度)
//    val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4), 2)
    //     scheduler.conf.getInt("spark.default.parallelism", totalCores)
    //    spark在默认情况下,从配置对象中获取配置参数:spark.default.parallelism
    //    如果获取不到,那么使用totalCores属性,这个属性取值为当前运行环境的最大可用核数,也可以自己配置
    val rdd: RDD[Int] = sc.makeRDD(List(1, 2, 3, 4))

    rdd.saveAsTextFile("output")


    //TODO 关闭环境
    sc.stop()
  }

}

读取内存数据时,数据可以按照并行度的设定进行数据的分区操作,数据分区规则的Spark 核心源码如下:

def positions(length: Long, numSlices: Int): Iterator[(Int, Int)] = {
    
     
  (0 until numSlices).iterator.map {
    
     i => 
    val start = ((i * length) / numSlices).toInt 
    val end = (((i + 1) * length) / numSlices).toInt 
    (start, end) 
  } 
  
}

读取文件数据时,数据是按照Hadoop 文件读取的规则进行切片分区,而切片规则和数
据读取的规则有些差异,具体 Spark 核心源码如下:

public InputSplit[] getSplits(JobConf job, int numSplits) 
    throws IOException {
    
     
 
    long totalSize = 0;                           // compute total size 
    for (FileStatus file: files) {
    
                    // check we have valid files 
      if (file.isDirectory()) {
    
     
        throw new IOException("Not a file: "+ file.getPath()); 
      } 
      totalSize += file.getLen(); 
    } 
 
    long goalSize = totalSize / (numSplits == 0 ? 1 : numSplits); 
    long minSize = Math.max(job.getLong(org.apache.hadoop.mapreduce.lib.input. 
      FileInputFormat.SPLIT_MINSIZE, 1), minSplitSize); 
       
    ... 
     
    for (FileStatus file: files) {
    
     
     
        ... 
     
    if (isSplitable(fs, path)) {
    
     
          long blockSize = file.getBlockSize(); 
          long splitSize = computeSplitSize(goalSize, minSize, blockSize); 
 
          ... 
 
  } 
  protected long computeSplitSize(long goalSize, long minSize, 
                                       long blockSize) {
    
     
    return Math.max(minSize, Math.min(goalSize, blockSize)); 
  } 

猜你喜欢

转载自blog.csdn.net/weixin_44480968/article/details/119656117

相关文章