栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

Spark—Task not serializable报错排查(RDD序列化)

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

Spark—Task not serializable报错排查(RDD序列化)

Spark-core—RDD序列化

文章目录
  • Spark-core—RDD序列化
    • 1、闭包检查
    • 2、序列化方法和属性
      • 1)Task not serializable报错原因
      • 2)报错修改
    • 3、序列化方法的案例2
    • 4、Kryo序列化框架

1、闭包检查
  • 从计算的角度, 算子以外的代码都是在 Driver 端执行, 算子里面的代码都是在 Executor端执行。那么在 scala 的函数式编程中,就会导致算子内经常会用到算子外的数据,这样就形成了闭包的效果。
  • 如果使用的算子外的数据无法序列化,就意味着无法传值给 Executor端执行,就会发生错误,所以需要在执行任务计算前,检测闭包内的对象是否可以进行序列化,这个操作我们称之为闭包检测。
2、序列化方法和属性

从计算的角度, 算子以外的代码都是在 Driver 端执行, 算子里面的代码都是在 Executor端执行。

1)Task not serializable报错原因
package Operator.action

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

object Spark07_RDD_Operator_Action {
  def main(args: Array[String]): Unit = {
    val sparkConf = new SparkConf().setAppName("Operator").setMaster("local[*]")
    val sc: SparkContext = new SparkContext(sparkConf)

    val rdd = sc.makeRDD(List(1, 2, 3, 4))
    val user = new User()

    rdd.foreach(
      num => {
        println( "age= " + (user.age+num))
      }
    )

    sc.stop()
  }

  class User{
    val age:Int=20
  }
}

运行以上代码,报错显示定义的User(类)没有序列化。

Exception in thread "main" org.apache.spark.SparkException: Task not serializable
Operator.action.Spark07_RDD_Operator_Action$User Serialization stack:


可是,它凭什么要序列化呢?

val user = new User()  //在行动算子外部创建了User ,在Driver端构建

    rdd.foreach(
      num => {
        println( "age= " + (user.age+num)) //在行动算子内部调用了User ,在Executor端调用
      }
    )

在Executor端调用Driver端的User,需要将Driver端的User传到Executor端。因为Driver和Executor共享数据数据,是需要传递数据的,所以User需要序列化

2)报错修改

定义User时混入Serializable

//方法一:定义User时混入Serializable
 class User extends Serializable {
    val age:Int=20
  }
  
  // 方法二:样例类在编译时,自动混入序列化特质(实现可序列化接口)
  case class User(){
    val age:Int=20
  }

问题成功解决,输出结果

3、序列化方法的案例2
package Acc

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

object Spark01_RDD_Serial {
  def main(args: Array[String]): Unit = {
    //1.创建 SparkConf 并设置 App 名称
    val conf: SparkConf = new SparkConf().setAppName("SparkCoreTest").setMaster("local[*]")
    //2.创建 SparkContext,该对象是提交 Spark App 的入口
    val sc: SparkContext = new SparkContext(conf)
    //3.创建一个 RDD
    val rdd: RDD[String] = sc.makeRDD(Array("hello world", "hello spark", "hive", "atguigu"))

    //3.1 创建一个 Search 对象
    val search = new Search("h")

    //3.2 函数传递,打印:ERROR Task not serializable
    search.getMatch1(rdd).collect().foreach(println)
    //3.3 属性传递,打印:ERROR Task not serializable
    search.getMatch2(rdd).collect().foreach(println)

    //如果类Search不进行序列化,那么getMatch1,getMatch2在调用时就会报 ERROR Task not serializable

    //4.关闭连接
    sc.stop()
  } }

//从数据源中查询指定规则的数据
//类的构造参数,其实是类的属性,构造参数需要进行闭包检测,其实就等同于类进行闭包检测
class Search(query:String) extends Serializable {
  def isMatch(s: String): Boolean = {
    s.contains(this.query)
  }
  // 函数序列化案例
  def getMatch1 (rdd: RDD[String]): RDD[String] = {
    rdd.filter(isMatch)  //采用外置函数
  }

  // 属性序列化案例
  def getMatch2(rdd: RDD[String]): RDD[String] = {
     // val s=query 如果加了这句,则getMatch2对于类Search不需要序列化,因为s为String,String已经继承序列化类;因为此时s是方法的局部变量,与Search无关
    rdd.filter(x => x.contains(query))  //采用匿名函数
  }
}

4、Kryo序列化框架
  • 参考地址: https://github.com/EsotericSoftware/kryo
  • Java 的序列化能够序列化任何的类。但是比较重(字节多),序列化后,对象的提交也比较大。Spark 出于性能的考虑,Spark2.0 开始支持另外一种 Kryo 序列化机制。
  • Kryo 速度是 Serializable 的 10 倍。当 RDD 在 Shuffle 数据的时候,简单数据类型、数组和字符串类型已经在 Spark 内部使用 Kryo 来序列化。
  • 注意:即使使用 Kryo 序列化,也要继承 Serializable 接口。
package Acc

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

object Spark01_RDD_serializable_Kryo {
  def main(args: Array[String]): Unit = {
    val conf: SparkConf = new SparkConf()
      .setAppName("SerDemo")
      .setMaster("local[*]")
      // 替换默认的序列化机制
      .set("spark.serializer", "org.apache.spark.serializer.KryoSerializer")
      // 注册需要使用 kryo 序列化的自定义类
      .registerKryoClasses(Array(classOf[Searcher]))


    val sc = new SparkContext(conf)
    val rdd: RDD[String] = sc.makeRDD(Array("hello world", "hello atguigu", "atguigu", "hahah"), 2)
    val searcher = new Searcher("hello")
    val result: RDD[String] = searcher.getMatchedRDD1(rdd)
    result.collect.foreach(println)
  }
}

case class Searcher(val query: String) {
  def isMatch(s: String) = {
    s.contains(query)
  }

  def getMatchedRDD1(rdd: RDD[String]) = {
    rdd.filter(isMatch)
  }

  def getMatchedRDD2(rdd: RDD[String]) = {
    val q = query
    rdd.filter(_.contains(q))
  }

}

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/978457.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号