初识Spark-core

已于 2022-06-04 11:54:03 修改
阅读量231 收藏
点赞数
分类专栏： spark-core spark 文章标签： spark scala big data
于 2022-06-04 11:48:24 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_49889089/article/details/125118962
版权

初识Spark-core

RDD的概念

RDD是指弹性分布式数据集，可以把RDD当成list使用

RDD五大特性

1、RDD由一组分区组成，默认一个block块对应一个分区

2、算子是作用在每一个分区上的，每一个切片对应一个task

3、RDD之间有一系列的依赖关系，有shuffle:宽依赖，没有shuffle:窄依赖

4、分区类的算子只能作用在KV格式的RDD上[groupBykey,sortBykey,reduceBykey]

5、spark为task提供了最佳计算位置，spark会将task发送到所在的数据结点执行

缓存级别的选择

首先了解读写速度
从内存中读取数据>从磁盘中读取数据>从网络中读取数据

缓存级别的选择，常用的有两个
1、如果内存充足，数据量不大，选择MEMORY_ONLY(默认)【仅内存】

2、如果内存不能完全放下所有的数据，选择MEMORY_AND_DISK_SER【内存和磁盘并且压缩】

算子的概念

算子的分类

1、转换算子（Transformations）
返回值是RDD
转换算子是懒执行，需要一个操作算子触发执行

2、操作算子（action）
返回值不是RDD
每一个action算子会触发一个任务

转换算子

1、map:一对一

map算子： 将rdd中的数据一行一行传递给后面的函数，及那个函数的返回值构建成一个新的rdd

mapPartitions: 将一个分区的数据传递给后面的函数，
一次处理一个分区的数据，需要返回一个迭代器

为什么是迭代器而不是集合，因为集合会将数据加载到内存中，
如果一个分区数据量太大会导致内存溢出

object Demo6Map {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()

    conf.setAppName("map")

    conf.setMaster("local")

    val sc = new SparkContext(conf)

    /**
      * 构建rdd方法
      * 1、读取文件
      * 2、基于scala集合构建rdd --- 一班用于测试
      *
      */

    //基于scala集合构建rdd
    val rdd1: RDD[Int] = sc.parallelize(List(1, 2, 3, 4, 5, 6, 7, 8, 9), 2)

    //getNumPartitions 不是一个算子，是一个普通的方法
    println(s"rdd1:${rdd1.getNumPartitions}")
    /**
      * map算子： 将rdd中的数据一行一行传递给后面的函数，及那个函数的返回值构建成一个新的rdd
      *
      */

    val rdd2: RDD[Int] = rdd1.map((i: Int) => i + 1)

    rdd2.foreach(println)


    /**
      * mapPartitions: 将一个分区的数据传递给后面的函数，
      * 一次处理一个分区的数据，需要返回一个迭代器
      *
      * 为什么是迭代器而不是集合，因为集合会将数据加载到内存中，
      * 如果一个分区数据量太大会导致内存溢出
      *
      */
    val rdd3: RDD[Int] = rdd1.mapPartitions((iter: Iterator[Int]) => {
      println("=" * 100)
      //对这个迭代器进行处理，这里是scala api
      val iterator: Iterator[Int] = iter.map((i: Int) => i * 2)
      //返回一个迭代器
      iterator
    })

    rdd3.foreach(println)

    /**
      * mapPartitionsWithIndex: 多了分区编号
      */

    val rdd4: RDD[Int] = rdd1.mapPartitionsWithIndex {
      case (index: Int, iter: Iterator[Int]) =>
        println(s"当前分区的编号:$index")

        iter
    }

    rdd4.foreach(println)
  }
}

2、filter:过滤

filter算子： 对数据进行过滤，函数返回treu保留数据，函数返回false过滤数据

object Demo7Filter {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()

    conf.setAppName("filter")

    conf.setMaster("local")

    val sc = new SparkContext(conf)


    val rdd1: RDD[Int] = sc.parallelize(List(1, 2, 3, 4, 5, 6, 7, 8, 9))

    /**
      * filter算子： 对数据进行过滤，函数返回treu保留数据，函数返回false过滤数据
      *
      */

    val filterRDD: RDD[Int] = rdd1.filter((i: Int) => {
      //保留偶数
      i % 2 == 0
    })

    filterRDD.foreach(println)

  }

}

3、flatmap:一行变多行

flatMap算子：将rdd中的数据一行一行传递给后面的函数，函数返回值必须是一个序列

flatMap会将返回的序列展开，构建成一个新的rdd

object Demo8FlatMap {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()

    conf.setAppName("filter")

    conf.setMaster("local")

    val sc = new SparkContext(conf)

    val rdd1: RDD[String] = sc.parallelize(List("java,spark,scala,hadoop", "hadoop,hive,hbase"))

    /**
      * flatMap算子：将rdd中的数据一行一行传递给后面的函数，函数返回值必须是一个序列
      * flatMap会将返回的序列展开，构建成一个新的rdd
      *
      */
    val rdd2: RDD[String] = rdd1.flatMap((str: String) => {
      str.split(",")
    })

    rdd2.foreach(println)
  }

}

4、sample:抽样

参数：（是否放回，抽样比列）
抽样不精确

object Demo9Sample {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()

    conf.setAppName("sample")

    conf.setMaster("local")

    val sc = new SparkContext(conf)

    val studentRDD: RDD[String] = sc.textFile("data/students.txt")

    /**
      * sample: 对数据进行抽样
      */

    val sampleRDD: RDD[String] = studentRDD.sample(false, 0.1)

    sampleRDD.foreach(println)
  }

}

5、groupBy&groupBykey

groupBy

指定一个分组的字段进行分组， 不需要一定是一个kv格式
返回的新的rdd的value里面保护所有的字段

groupBykey

rdd必须是一个kv格式
返回的新的rdd的迭代器中的数据只包含value, 后续在处理数据的时候方便一点，指定key进行分组，返回值只有(k,v)，可以减少shuffle过程传输的数据量

object Demo10Group {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()

    conf.setAppName("group")

    conf.setMaster("local")

    val sc = new SparkContext(conf)

    //统计学生的总分

    val linesRDD: RDD[String] = sc.textFile("data/score.txt")

    //取出学号和分数
    val scoreRDD: RDD[(String, Int)] = linesRDD
      .map(line => line.split(","))
      .filter(arr => arr.length == 3)
      .map {
        case Array(id: String, _: String, sco: String) =>
          (id, sco.toInt)
      }

    /**
      * groupBy: 指定一个分组的字段进行分组，  不需要一定是一个kv格式
      * 返回的新的rdd的value里面保护所有的字段
      *
      */

    val groupByRDD: RDD[(String, Iterable[(String, Int)])] = scoreRDD.groupBy(kv => kv._1)


    groupByRDD
      .map {
        case (id: String, iter: Iterable[(String, Int)]) =>
          val sumSco: Int = iter.map(_._2).sum
          (id, sumSco)
      }
      .foreach(println)

    /**
      * groupByKey: rdd必须是一个kv格式
      * 返回的新的rdd的迭代器中的数据只包含value, 后续在处理数据的时候方便一点
      *
      * groupByKey: 可以减少shuffle过程中传输的数据量，效率比groupBy高
      *
      */

    val groupByKeyRDD: RDD[(String, Iterable[Int])] = scoreRDD.groupByKey()

    groupByKeyRDD
      .map {
        case (id: String, iter: Iterable[Int]) =>
          (id, iter.sum)
      }
      .foreach(println)

    while (true) {

    }
  }

}

6、ReduceByKey

ReduceByKey
对相同的key的value进行聚合计算， 需要一个聚合函数

reduceBykey会在map端进行预聚合，可以减少shuffle过程中需要传输的数据量，效率比GrouByKey高
能使用reducekeyKey的时候尽量使用reduceByKey

对同一个key的value做聚合
聚合次数=value数-1

局限性：不能处理太复杂的逻辑

使用范围：必须是K，V格式才能使用

object Demo11ReduceByKey {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()

    conf.setAppName("group")

    conf.setMaster("local")

    val sc = new SparkContext(conf)

    //统计学生的总分

    val linesRDD: RDD[String] = sc.textFile("data/score.txt")

    //取出学号和分数
    val scoreRDD: RDD[(String, Int)] = linesRDD
      .map(line => line.split(","))
      .filter(arr => arr.length == 3)
      .map {
        case Array(id: String, _: String, sco: String) =>
          (id, sco.toInt)
      }

    /**
      * groupByKey: 先分组，分组之后对对value进行聚合计算
      *
      */
    scoreRDD
      .groupByKey()
      .map(kv => (kv._1, kv._2.sum))
      .foreach(println)

    /**
      * reduceByKey: 对相同的key的value进行聚合计算， 需要一个聚合函数
      *
      * reduceBykey会在map端进行预聚合，可以减少shuffle过程中需要传输的数据量，效率比GrouByKey高
      * 能使用reducekeyKey的时候尽量使用reduceByKey
      *
      */

    val countRDD: RDD[(String, Int)] = scoreRDD.reduceByKey((x: Int, y: Int) => {
      val j: Int = x + y
      //println(s"$x + $y = $j")
      j
    })

    countRDD.foreach(println)

    while (true) {

    }
  }

}

7、union

合并两个rdd，不会对数据做去重，两个rdd的数据类型要完全一致，在物理层面没有合并，只是在逻辑层面合并了

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


    val conf = new SparkConf()

    conf.setAppName("union")

    conf.setMaster("local")

    val sc = new SparkContext(conf)


    val rdd1: RDD[Int] = sc.parallelize(List(1, 2, 3, 4, 5, 6))
    val rdd2: RDD[Int] = sc.parallelize(List(3, 4, 5, 6, 7, 8, 9))

    println(s"rdd1:${rdd1.getNumPartitions}")
    println(s"rdd2:${rdd2.getNumPartitions}")


    /**
      * union :合并两个rd, 不会对数据做去重， 两个rdd的类型要完全一致
      * 在物理层面并没有合并,只是在逻辑层面合并了
      */
    val unionRDD: RDD[Int] = rdd1.union(rdd2)

    println(s"unionRDD:${unionRDD.getNumPartitions}")

    unionRDD.foreach(println)


  }

}

8、join

join分类

join:内连接，取出左右两个表都有的数据

leftOuterjoin:左连接，以左表为基础，如果右表没有这个数据补None

rightOuterjoin:右连接，以右表为基础，如果左表没有这个数据补None

fullOuterjoin:全连接，左右两个并集的数据，没有数据的补None

join

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


    val conf = new SparkConf()

    conf.setAppName("union")

    conf.setMaster("local")

    val sc = new SparkContext(conf)


    val idNameRDD: RDD[(String, String)] = sc.parallelize(List(
      ("000", "晓伟"),
      ("001", "张三"),
      ("002", "李四"),
      ("003", "王五"))
    )
    val idAgeRDD: RDD[(String, Int)] = sc.parallelize(List(
      ("001", 23),
      ("002", 24),
      ("003", 25),
      ("004", 23))
    )

    /**
      * innerJoin: 两个表都有才能关联上
      *
      */

    val innerJoinRDD: RDD[(String, (String, Int))] = idNameRDD.join(idAgeRDD)

    //整理数据
    innerJoinRDD
      .map {
        case (id: String, (name: String, age: Int)) =>
          (id, name, age)
      }
      .foreach(println)


    /**
      * leftOuterJoin： 以左表为基础，如果右表没有这个key，补NOne
      *
      * Option: 可选择的值，有值或者没有值
      */


    val leftJoinRDD: RDD[(String, (String, Option[Int]))] = idNameRDD.leftOuterJoin(idAgeRDD)

    //整理数据
    leftJoinRDD
      .map {

        //关联上的处理方式
        case (id: String, (name: String, Some(age))) =>
          (id, name, age)

        //没有关联上的处理方式
        case (id: String, (name: String, None)) =>
          //给年龄一个默认值
          (id, name, 0)

      }
      .foreach(println)

    /**
      *
      * fullOuterJoin: 以两个表为基础，有一边有数据就会出来结果，列一边补None
      *
      */


    val fullJoinRDD: RDD[(String, (Option[String], Option[Int]))] = idNameRDD.fullOuterJoin(idAgeRDD)


    fullJoinRDD
      .map {
        case (id: String, (Some(name), None)) =>
          (id, name, 0)

        case (id: String, (None, Some(age))) =>
          (id, "默认值", age)

        case (id: String, (Some(name), Some(age))) =>
          (id, name, age)
      }
      .foreach(println)
  }

}

9、mapvalues

key不变，只对values做处理

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

    val conf = new SparkConf()

    conf.setAppName("union")

    conf.setMaster("local")

    val sc = new SparkContext(conf)

    val idAgeRDD: RDD[(String, Int)] = sc.parallelize(List(
      ("001", 23),
      ("002", 24),
      ("003", 25),
      ("004", 23))
    )

    /**
      * mapValues: key不变，对value做处理
      *
      */
    val rdd: RDD[(String, Int)] = idAgeRDD.mapValues(age => age + 1)

    rdd.foreach(println)
  }

}

10、sortBy&sortBykey

sortBy: 指定一个字段进行排序
sortByKey;通过key进行排序
默认是升序

object Demo16Sort {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()

    conf.setAppName("group")

    conf.setMaster("local")

    val sc = new SparkContext(conf)

    val linesRDD: RDD[String] = sc.textFile("data/score.txt")

    //取出学号和分数
    val scoreRDD: RDD[(String, Int)] = linesRDD
      .map(line => line.split(","))
      .filter(arr => arr.length == 3)
      .map {
        case Array(id: String, _: String, sco: String) =>
          (id, sco.toInt)
      }

    //计算总分
    val sumScoreRDD: RDD[(String, Int)] = scoreRDD.reduceByKey(_ + _)
    /**
      * sortBy: 指定一个字段进行排序
      * sortByKey;通过key进行排序
      * 默认是升序
      *
      */

    val sortByRDD: RDD[(String, Int)] = sumScoreRDD.sortBy(kv => kv._2, ascending = false)
    sortByRDD.foreach(println)

  }

}

11、distinct:去重

distinct: 对数据去重，会产生shuffle

object Demo17Distinct {
  def main(args: Array[String]): Unit = {
    val conf = new SparkConf()

    conf.setAppName("group")

    conf.setMaster("local")

    val sc = new SparkContext(conf)

    val rdd1: RDD[Int] = sc.parallelize(List(1, 2, 3, 4, 5, 7, 87, 9, 4, 4, 3, 2, 4, 5, 6))

    /**
      * distinct: 对数据去重，会产生shuffle
      *
      */
    val distinctRDD: RDD[Int] = rdd1.distinct()

    distinctRDD.foreach(println)
  }

}

操作算子(action)

action算子，每一个action算子都会产生一个job

1、count

统计RDD数据的行数

sql中count(1)与count(*)的区别
count(1) ，这一行分组的字段都为null不计数
count(*) ，这一行所有的都为null不计数

2、sum

对rdd中的数据求和，rdd中的数据类型必须是数字

3、take

取top, 返回一个数组， 不能取太多， 会导致内存溢出

4、collect

将rdd转换成数组，如果rdd数据量比较大，会导致内存溢出 （1G）

5、foreach

遍历rdd中的数据，也是一个action算子

6、foreachPartition

一次将一个分区的数据传递给后面的函数

7、saveAsTextFile

将数据保存在hdfs中

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

    val conf = new SparkConf()

    conf.setAppName("group")

    conf.setMaster("local")

    val sc = new SparkContext(conf)

    val studentRDD: RDD[String] = sc.textFile("data/students.txt")

    /**
      * action算子，每一个action算子都会产生一个job
      *
      */

    /**
      * count: 统计rdd的数据行数
      */
    val count: Long = studentRDD.count()

    println(count)

    /**
      * sum: 对rdd中的数据求和，rdd中的数据类型必须是数字
      *
      */

    val sumAge: Double = studentRDD
      .map(line => line.split(",")(2).toInt)
      //对所有数据求和，只能是数字类型
      .sum()

    println(sumAge / count)


    /**
      * take: 取top, 返回一个数组， 不能取太多， 会导致内存溢出
      *
      */

    val top: Array[String] = studentRDD.take(10)

    top.foreach(println)

    /**
      * collect: 将rdd转换成数组，如果rdd数据量比较大，会导致内存溢出  （1G）
      */


    val array: Array[String] = studentRDD.collect()

    array.foreach(println)


    /**
      * foreach: 遍历rdd中的数据，也是一个action算子
      * foreachPartition: 一次将一个分区的数据传递给后面的函数
      *
      */

    studentRDD.foreach(println)


    studentRDD.foreachPartition((iter: Iterator[String]) => {
      iter.foreach(println)
    })

    /**
      * saveAsTextFile: 将数据保存在hdfs中
      *
      */

    HDFSUtil.deletePath("data/test")
    studentRDD.saveAsTextFile("data/test")


    while (true) {}
  }
}
BigDataTuTu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
初识 Spark - 7000字+15张图解，学习 Spark 入门基础知识
欢迎关注数据类微信公众号：数人之道，分享数据知识、干货、资讯
02-23 886
欢迎关注「数人之道」公众号 获取更多数据知识、干货、资讯！ 延伸阅读： 初识 Spark | 带你理解 Spark 中的核心抽象概念：RDDSpark RDD 的概念、操作、依赖关系https://mp.weixin.qq.com/s?__biz=MzkwNTI4MDEzOQ==&mid=2247485795&idx=1&sn=5ec304fde1d31f6e269d8ddcb07e8c1c&chksm=c0fb6687f78cef91bd2b81fb5602e...
04-Spark入门
PenguinLittle的博客
03-01 1887
04-Spark入 熟悉spark相关概念 搭建spark集群 编写简单的spark应用程序 2.spark概述 2.1.什么是spark spark是基于内存的快速、通用、可扩展的大数据分析计算引擎。它的计算速度非常快。但是仅仅只涉及到数据的计算，并没有涉及到数据的存储。 2.2.为什么要学习spark 运行速度比mapred uce快很多 2.3.spark特点 速度快（比mapreduce在内存中快100倍，在磁盘中快10倍） spark中的job中间结果可以不落地，
Spark初识 --- spark-core Rdd的创建及分类
懂得一千零一种,赋予你失败的方法！
11-17 204
Spark初识 spark与hadoop的历史回顾 Spark框架与Hadoop框架的对比 Spark本身是一个并行的计算框架 — RDD(支持分区) 一、RDD是弹性分布式数据集 二、RDD特点： 1.RDD是数据集 --- RDD中保存了指定路径下的数据文件中的数据集，其实真实存储的是逻辑执行计划，在Action操作之后才会收集到对应的数据集或者是进行shuffle操作后。 2.RDD是一个编程模型 --- RDD变量可以调用内部的对应方法 3.RDD
3.2.1 spark体系之分布式计算-spark-core之离线计算-初识Spark
敲代码的乔帮主
10-21 765
目录 1.什么是Spark 2.总体技术栈 3.Spark演变历史 4.Spark与MapReduce的区别 5.Spark运行模式 1.什么是Spark Apache Spark 是专为大规模数据处理而设计的快速通用的计算引擎。Spark是UC Berkeley AMP lab (加州大学伯克利分校的AMP实验室)所开源的类Hadoop MapReduce的通用并行计算框架，Spark拥有Hadoop MapReduce所具有的优点；但不同于MapReduce的是Job中间输出结果可以保存在
Spark基础篇-初识Spark
angeliacmm的博客
05-05 374
第一章 初识Spark 1.认识Spark Spark是加州大学伯克利分校AMP实验室开发基于内存的通用并行计算框架。 思考：已经学习了MapReduce，为什么要学习Spark？ 1.1并行计算 并行计算（Parallel Computing）是指同时使用多种计算资源解决计算问题的过程，是提高计算机系统计算速度和处理能力的一种有效手段。 它的基本思想是：用多个处理器来协同求解同一问题。 注意，其实就是将被求解的问题分解成若干个部分，各部分均由一个独立的处理机来并行计算 并行计算系统： 既可以是专门设
Spark初识-什么是Spark
栗筝i的博客
12-17 6478
Spark是一个基于内存的开源计算框架，于2009年诞生于加州大学伯克利分校AMPLab（AMP：Algorithms，Machines，People），它最初属于伯克利大学的研究性项目，后来在2010年正式开源，并于 2013 年成为了 Apache 基金项目，到2014年便成为 Apache 基金的顶级项目，该项目整个发展历程刚过六年时间，但其发展速度非常惊人。 正由于Spark来自于大学，其整个发展过程都充满了学术研究的标记，是学术带动Spark核心架构的发展，如弹性分布式数据集（RDD，resi..
Spark基础篇-Spark-Core核心模型（一）
angeliacmm的博客
05-05 881
第二章 Spark-Core核心模型 1.RDD 弹性分布式数据集（Resilient Distributed Dataset）是Spark中最基本的数据抽象。 不可变（只读） 可分区 可并行计算 自动容错 位置感知性调度 RDD是Spark的核心抽象模型，本质上是一个抽象类。RDD源代码部分重点代码实现如下： abstract class RDD[T: ClassTag]( @transient private var _sc: SparkContext, @transie
Spark基础篇-Spark-Core核心模型（二）
angeliacmm的博客
05-08 342
第二章 Spark-Core核心模型（二） 3.分区计算 Spark中RDD的计算是以分区为单位的，每个RDD都会实现compute函数以达到这个目的。 /** * :: DeveloperApi :: * Implemented by subclasses to compute a given partition. */ @DeveloperApi def compute(split: Partition, context: TaskContext): Iterator[T] 注意，该属性
Spark初识-Spark基本架构概览使用
栗筝i的博客
12-24 2321
当需要处理的数据量超过了单机尺度(比如我们的计算机有4GB的内存，而我们需要处理100GB以上的数据)这时我们可以选择spark集群进行计算，有时我们可能需要处理的数据量并不大，但是计算很复杂，需要大量的时间，这时我们也可以选择利用spark集群强大的计算资源，并行化地计算 一、架构及生态 架构示意图如下： Spark Core：实现了 Spark 的基本功能，包含任务调度、内存管理、错误恢复、与存储系统交互等模块。SparkCore 中还包含了对弹性分布式数据集(Resilient Distrib.
fantj2016#java-reader#3. Spark-初识RDD1
07-25
（1）一组分片（Partition），即数据集的基本组成单位 （2）一个计算每个分区的函数 （3）RDD之间的依赖关系 （4）一个Partitioner，即RD
初识C语言 - 复习.zip
06-13
【初识C语言 - 复习】 C语言是一种强大的、结构化的编程语言，它以其高效、灵活和可移植性而闻名。本复习资料旨在帮助初学者巩固C语言的基础知识，以便更好地理解和应用这一编程工具。 一、C语言概述 C语言由...
初识Spark入门
08-25
Spark包含了大数据领域常见的各种计算框架，包括spark core（离线计算）、spark sql（交互式查询）、spark streaming（实时计算）、Spark MLlib（机器学习）和Spark GraphX（图计算）。 Spark的特点包括速度快、...
初识计算机-PPT.ppt
06-13
这篇初识计算机的内容主要针对小学三年级的学生，旨在引导他们认识计算机的基础知识。 首先，计算机的种类有三种基本类型：台式计算机、便携式计算机（笔记本电脑）和掌上计算机（掌上电脑）。台式计算机通常用于...
初识Hive--精华
10-22
1、hive的产生背景 2、hive的定义 3、hive的本地安装 4、hive的基本类型 5、hive的基本命令
Spark核心知识要点（三）
ytp552200ytp的博客
07-25 899
Spark核心知识要点（三）
大数据处理：大数据处理框架Hadoop、Spark
Chujun123528的博客
07-24 1019
大数据处理是当代信息技术领域的一个重要分支，它涉及到海量数据的存储、管理和分析。为了高效地应对大数据处理的挑战，多种框架被开发出来，其中Hadoop和Spark是最为知名和广泛应用的两种。以下将详细介绍这两种框架以及它们在大数据处理中的应用和优势。
Scala学习笔记20: Future 和Promise
Taerge0110的博客
07-26 378
在 Scala 中, `Future` 和 `Promise` 是用于处理异步操作的强大工具 ; 它们就像一对搭档, 协同工作, 优雅地管理着那些需要花费时间的任务 .
SpinalHDL之仿真（一）
最新发布
m0_59092412的博客
07-31 645
本文作为SpinalHDL学习笔记第二十九篇，介绍SpinalHDL仿真相关内容。与往常一样，可以使用标准仿真工具来仿真 SpinalHDL 生成的 VHDL/Verilog。然而，从 SpinalHDL 1.0.0开始，该语言集成了一个 API 来编写测试平台并直接在 Scala 中测试您的硬件。该 API 提供了读取和写入 DUT 信号、分裂和合并仿真的进程、休眠和等待直到达到给定条件的功能。
3.2.1 spark体系之分布式计算-spark-core之离线计算-初识spark
06-28
Spark的核心是Spark Core，它提供了分布式任务调度、内存计算和数据管理等功能。Spark支持多种编程语言，包括Java、Scala和Python等。Spark的离线计算能力非常强大，可以处理大规模的数据集，支持复杂的数据处理和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值