程序博客网 > 海湾报警主机编程实例

关于Spark的Broadcast解析

来源：互联网 发布：海湾报警主机编程实例 编辑：程序博客网 时间：2024/06/05 04:01



首先，推荐下大神（anzhsoft）的文章，http://blog.csdn.net/column/details/spark.html

仅作为大神未未提到的细枝末节，进行补充。

编写文章格式，亦是参考大神博文样式“照虎画猫”


Broadcast（广播）是相对较为常用方法功能，通常使用方式，包括共享配置文件，map数据集，树形数据结构等，为能够更好更快速为TASK任务使用相关变量。

期间，曾见过有童鞋用原始日志（log）进行广播，导致集群运行缓慢，诸位童鞋可以引此为戒，其与JAVA的ServletContext的作用近似，ServletContext存放过多数据也会内存溢出的，Broadcast虽然不会溢出（使用内存+硬盘方式），但是依然会影响运行。

基础使用：

[java] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. <span style="font-size:18px;">val broadcastValue = sc.broadcast(存储值)  
  2. broadcastValue .value</span>  

我们从三个方面叙述Broadcast，初始化、创建（写入）、使用


初始化

Broadcast是典型的建造者模式方法，相对内部设计相对较为简单，同时初始化并非直接创建Broadcast对象，作用有两个方面：

1. 依据配置属性（spark.broadcast.factory）创建BroadcastFactory对象 - 反射创建。

2. 将sparkConf对象注入Broadcast中，同时定义压缩编码


初始化入口sparkContext启动时创建，其调用顺序为（后续有时间调整为时序图）：

  1. SparkContext#构造方法
  2. SparkEnv#create
  3. BroadcastManager#initialize（）
  1. TorrentBroadcastFactoryr#initialize（isDriver: Boolean, conf: SparkConf, securityMgr: SecurityManager）
  2. TorrentBroadcast#initialize(_isDriver: Boolean, conf: SparkConf)



1. 创建过程中，初始化Env配置环境时创建BroadcastManager对象，相关代码为：

SparkContext：

[java] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. <span style="font-size:18px;">  // Create the Spark execution environment (cache, map output tracker, etc)  
  2.   // 创建spark的执行环境  
  3.   private[spark] val env = SparkEnv.create(  
  4.     conf, // spark配置文件  
  5.     "<driver>",  
  6.     conf.get("spark.driver.host"), // 主机名  
  7.     conf.get("spark.driver.port").toInt, // 端口号  
  8.     isDriver = true, // 默认启动SparkContext客户端，便是Driver  
  9.     isLocal = isLocal,// 是否是本地运行，是通过master获取该值，如果是submit提交，请参考SparkSubmitArguments类，会将参数转换为master  
  10.     listenerBus = listenerBus   
  11.     /* spark监听总线（LiveListenerBus）,他是负责监听spark事件，包括job启动和介绍、BlockManage的添加等等，简单理解UI能看到的变化都是这块监听的， 
  12.      * 如果有时间，可以将这块与大家分享一下，底层使用队列实现，典型观察者模式实现，未使用akka实现 */  
  13.     )  
  14.   SparkEnv.set(env) // 注册SparkEnv对象</span>  

SparkEnv：

[java] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. <span style="font-size:18px;">val blockManager = new BlockManager(executorId, actorSystem, blockManagerMaster,  
  2.       serializer, conf, securityManager, mapOutputTracker, shuffleManager)  
  3.   
  4. val connectionManager = blockManager.connectionManager  
  5.   
  6. val broadcastManager = new BroadcastManager(isDriver, conf, securityManager)  
  7.   
  8. val cacheManager = new CacheManager(blockManager)</span>  

2.BroadcastManager构造函数调用initialize方法构建

[java] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. <span style="font-size:18px;">// Called by SparkContext or Executor before using Broadcast  
  2.   // 一个context仅初始化一次，默认是Torrent  
  3.   private def initialize() {  
  4.     // TODO 初始化BroadcastFactory  
  5.     // 1.确定仅有第一次进入时，创建BroadcastFactory对象  
  6.     // 2.初始化BroadcastFactory，并与BroadcastManager建立hook  
  7.       
  8.     synchronized {  
  9.       // 1.0 如果第一次进入，初始化BroadcastFactory  
  10.       if (!initialized) {  
  11.         // 2.0 反射创建BroadcastFactory  
  12.         val broadcastFactoryClass =  
  13.           conf.get("spark.broadcast.factory", "org.apache.spark.broadcast.TorrentBroadcastFactory")  
  14.         broadcastFactory =  
  15.           Class.forName(broadcastFactoryClass).newInstance.asInstanceOf[BroadcastFactory]  
  16.   
  17.         // 2.1 初始化BroadcastFactory，并与BroadcastManager建立hook  
  18.         broadcastFactory.initialize(isDriver, conf, securityManager)  
  19.         // 2.2 表示第一次进入完毕  
  20.         initialized = true  
  21.       }  
  22.     }  
  23.   }</span>  

3. TorrentBroadcastFactory调用initialize方法

[java] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. <span style="font-size:18px;">override def initialize(isDriver: Boolean, conf: SparkConf, securityMgr: SecurityManager) {  
  2.     TorrentBroadcast.initialize(isDriver, conf)  
  3. }</span>  


4.最终将sparkConf对象注入Broadcast中，同时定义压缩方式

[java] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. <span style="font-size:18px;">  /** 初始化TorrentBroadcast属性 */  
  2.   def initialize(_isDriver: Boolean, conf: SparkConf) {  
  3.     TorrentBroadcast.conf = conf // TODO: we might have to fix it in tests  
  4.     synchronized {  
  5.       if (!initialized) {  
  6.         compress = conf.getBoolean("spark.broadcast.compress", true)  
  7.         compressionCodec = CompressionCodec.createCodec(conf)  
  8.         initialized = true  
  9.       }  
  10.     }  
  11.   }</span>  

以上是sparkContext创建时完成broadcast，即便我们没有使用broadcast相关功能依然会进行创建，同时也表示broadcast类型，broadcast压缩方式是开始便定义，无法实现app中不同job使用不同的broadcast，TorrentBroadcast和HttpBroadcast无法并存。

spark默认使用TorrentBroadcast（并发），效率相对要比http要好，同时避免单机热点的产生，比较适合分布式系统的思想。

 思想类似于迅雷BT下载，已使用的executor越多，及速度越快。

创建（写入）：

driver首先要将值序列化到byteArray中，然后在按block大小进行分割（默认是4M），将信息存放在driver的blockmanage中，并通知blockmanage-master，完成注册，并可以让所有executor,存储方式内存+硬盘

使用write顺序：

1.   SparkContext#broadcast  外层方法，使用sc.broadcast 进行广播

2.   BroadcastManager#newBroadcast(value_ : T, isLocal: Boolean)

3.   TorrentBroadcastFactory#newBroadcast(value_ : T, isLocal: Boolean, id:Long)

4.   TorrentBroadcast#构造函数

5.   TorrentBroadcast#writeBlocks

6.   BlockManage#putBytes(

      blockId: BlockId,

      bytes: ByteBuffer,

      level: StorageLevel,

      tellMaster: Boolean = true,

      effectiveStorageLevel:Option[StorageLevel] = None)  最终存储

 

使用广播较为简单，如果sparkContext为长期有效执行多个job,则考虑注销广播，同时尽量广播要小（不然你会死的很惨^_^, 可以试试，嘿嘿）

代码如下：

[java] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. <span style="font-size:18px;">val broadcastValue = sc.broadcast(存储值) // 注册  
  2. broadcastValue.unpersist() // 注销方法一  
  3. SparkEnv.get.broadcastManager.unbroadcast(id, false, false) // 注销方法二</span>  
创建时，使用SparkContext的broadcast方法，并将值一值传递至TorrentBroadcast，并构建TorrentBroadcast对象，同时完成将值交给BlockManage进行注册，并序列化在本地存储。（SparkEnv.get.blockManager.putBytes方法）
[java] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. <span style="font-size:18px;">private[spark] class TorrentBroadcast[T: ClassTag](  
  2.     obj : T,  
  3.     @transient private val isLocal: Boolean,  
  4.     id: Long)  
  5.   extends Broadcast[T](id) with Logging with Serializable {  
  6.   
  7.   
  8.  /** 1.driver是直接读取本地的值 
  9.   *  2.其他executor是依靠blockManager读取（readObject） */  
  10.   @transient private var _value: T = obj  
  11.   
  12.   /* 固定格式： 
  13.   * broadcastId = broadcast_广播ID 
  14.   * blockID = broadcast_广播ID_piece[1,2,3,4] */  
  15.   private val broadcastId = BroadcastBlockId(id)  
  16.   
  17.   /** 1.广播值交给blockManager管理 
  18.    *  2.广播转换为ByteArray，返回数据块的长度 */  
  19.   private val numBlocks: Int = writeBlocks()  
  20.   
  21.   override protected def getValue() = _value</span>  

writeBlocks是主要执行方法，主要功能便是按照定义的广播块大小切分数据（默认是4M，spark.broadcast.blockSize），其后将块注册blockManage，并写入本地磁盘中。
writeBlocks(){
   1.blockifyObject  数据切分方法
   2.BlockManage.putBytes  数据存储方法
}
blockifyObject其实算是较为通用的方法，写法也蛮实用，可以作为项目工具类使用，此处也将注释后贴给大家分享：
[java] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. <span style="font-size:18px;"> /** 切分数据，方法较为实用，可作为工具类，已收藏 
  2.    *  @param obj 切分数据对象 */  
  3.   def blockifyObject[T: ClassTag](obj: T): Array[ByteBuffer] = {  
  4.     // TODO: Create a special ByteArrayOutputStream that splits the output directly into chunks  
  5.     // so we don't need to do the extra memory copy.  
  6.     // TODO 数据切块，按照默认的4M切分数据块，返回4MByteBuffer(数据体检变小)  
  7.     //      数据 -> 压缩 -> 序列化 -> 分割  
  8.     // 1. 声明输出流（定义压缩方式和序列化）  
  9.     // 2. 压缩后数据按4M进行分割  
  10.     // 3. 返回ByteBuffer字符  
  11.       
  12.     // 1.0 定义输出流  
  13.     val bos = new ByteArrayOutputStream()  
  14.     // 1.1 包装压缩方式  
  15.     val out: OutputStream = if (compress) compressionCodec.compressedOutputStream(bos) else bos  
  16.     // 1.2 创建序列化对象  
  17.     val ser = SparkEnv.get.serializer.newInstance()  
  18.     // 1.3 包装序列化输出流（默认java序列化，不过一般推荐KryoSerializer，建议修改spark-defaults.conf）  
  19.     val serOut = ser.serializeStream(out)  
  20.     // 1.4 将value写至ByteArray中  
  21.     serOut.writeObject[T](obj).close()  
  22.     val byteArray = bos.toByteArray  
  23.     // 2.0 将ByteArray转换为输入流  
  24.     val bais = new ByteArrayInputStream(byteArray)  
  25.     // 2.1 获取分割块数，ceil有余数+1  
  26.     val numBlocks = math.ceil(byteArray.length.toDouble / BLOCK_SIZE).toInt  
  27.     // 2.2 定义数据块集合  
  28.     val blocks = new Array[ByteBuffer](numBlocks)  
  29.     // 2.3 定义块ID  
  30.     var blockId = 0  
  31.     // 2.4 循环按4M分割数据块,步长为4M  
  32.     for (i <- 0 until (byteArray.length, BLOCK_SIZE)) {  
  33.       // 2.4.1 定义装载4M的byte的容器  
  34.       val thisBlockSize = math.min(BLOCK_SIZE, byteArray.length - i)  
  35.       val tempByteArray = new Array[Byte](thisBlockSize)  
  36.       // 2.4.2 装载数据  
  37.       bais.read(tempByteArray, 0, thisBlockSize)  
  38.       blocks(blockId) = ByteBuffer.wrap(tempByteArray)  
  39.       // 2.4.3 index加一  
  40.       blockId += 1  
  41.     }  
  42.     // 3.0 切分结束，关闭流  
  43.     bais.close()  
  44.     // 3.1 返回流  
  45.     blocks  
  46.   }</span>  
读取：
broadcase写入是优先写入依据存储策略写入本地（BlockManage#putBytes方法），既然序列化数据是本地存储，由此而来的问题是读取问题，BlockManage存储数据并不似hdfs会依据备份策略存储多份数据放置不同节点（但是多提一句，spark的taskScheblue是拥有类似机架感知策略分配任务），如没有备份数据，那么必然产生一下数个问题：
   1.节点故障，无法访问节点数据
   2.数据热点，所有任务皆使用该数据
   3.网络传输，所有节点频繁访问单节点
那么解决该问题，spark并没有使用HDFS的思想，而选择是P2P点对点方式（BT下载）解决问题，是只要使用过broadcase数据，则在本接节点存储数据，由此变成新的数据源，随和数据源不断增加速度也会越来越快，刚开始传输则相对会慢一些，同时，以上不建议使用大文件broadcase，亦是如此，如果使用较为频繁的数据，他相当于每个节点都要存储一份，形成网状传输方式交换数据，因此建议存储配置文件或某种数据结构为上佳选择。
 
调用顺序：
TorrentBroadcast#readObject()
TorrentBroadcast#readBlocks()
BlockManage#getLocalBytes(blockId:BlockId) / getRemoteBytes(blockId: BlockId)
BlockManage#putBytes()
 
readObject是broadcase读取的主方法，管理整个读取策略
[java] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. <span style="font-size:18px;"> /** Used by the JVM when deserializing this object. */  
  2.   private def readObject(in: ObjectInputStream) {  
  3.     // TODO 读取广播变量，有便读取本地，没有则远程并存储在本地  
  4.       
  5.     // 1.0 可读取对象中静态变量  
  6.     in.defaultReadObject()  
  7.     // 2.0 读取广播变量（单个executor独享）  
  8.     TorrentBroadcast.synchronized {  
  9.       // 2.1 读取本地广播数据  
  10.       SparkEnv.get.blockManager.getLocal(broadcastId).map(_.data.next()) match {  
  11.         // 2.2 获取本地数据成功  
  12.         case Some(x) =>  
  13.           _value = x.asInstanceOf[T]  
  14.         // 2.3 获取本地数据失败  
  15.         case None =>  
  16.           // 2.4 获取Blocks，同时将块存储到本地  
  17.           logInfo("启动读取 broadcast variable " + id)  
  18.           val start = System.nanoTime()  
  19.           val blocks = readBlocks()  
  20.           val time = (System.nanoTime() - start) / 1e9  
  21.           logInfo("Reading broadcast variable " + id + " took " + time + " s")  
  22.   
  23.           // 2.5 将数据块反序列化，并解压缩  
  24.           _value = TorrentBroadcast.unBlockifyObject[T](blocks)  
  25.           // Store the merged copy in BlockManager so other tasks on this executor don't  
  26.           // need to re-fetch it.  
  27.           SparkEnv.get.blockManager.putSingle(  
  28.             broadcastId, _value, StorageLevel.MEMORY_AND_DISK, tellMaster = false)  
  29.       }  
  30.     }  
  31.   }</span>  

readBlocks则是实现P2P思想的具体实现者
[java] view plain copy print?在CODE上查看代码片派生到我的代码片
  1. <span style="font-size:18px;"> /** Fetch torrent blocks from the driver and/or other executors. */  
  2.   private def readBlocks(): Array[ByteBuffer] = {  
  3.     // Fetch chunks of data. Note that all these chunks are stored in the BlockManager and reported  
  4.     // to the driver, so other executors can pull these chunks from this executor as well.  
  5.       
  6.     // 1.0 定义数据块集合  
  7.     val blocks = new Array[ByteBuffer](numBlocks)  
  8.     // 1.1 引用blockManager  
  9.     val bm = SparkEnv.get.blockManager  
  10.       
  11.     // 2.0 循环遍历所有块，避免访问热点，随机顺序读  
  12.     for (pid <- Random.shuffle(Seq.range(0, numBlocks))) {  
  13.       // 2.1 组装块ID  
  14.       val pieceId = BroadcastBlockId(id, "piece" + pid)  
  15.   
  16.       // First try getLocalBytes because  there is a chance that previous attempts to fetch the  
  17.       // broadcast blocks have already fetched some of the blocks. In that case, some blocks  
  18.       // would be available locally (on this executor).  
  19.       // 2.2 他会先查本地，继而查询远程，但是前面已经查找的是广播，现在查找的是认数据块（区别）  
  20.       var blockOpt = bm.getLocalBytes(pieceId)  
  21.       // 2.3 如果本地为查询到结果，则通过blockManager远程获取，并将数据存储到本地  
  22.       if (!blockOpt.isDefined) {  
  23.         blockOpt = bm.getRemoteBytes(pieceId)  
  24.         blockOpt match {  
  25.           case Some(block) =>  
  26.             // If we found the block from remote executors/driver's BlockManager, put the block  
  27.             // in this executor's BlockManager.  
  28.             SparkEnv.get.blockManager.putBytes(  
  29.               pieceId,  
  30.               block,  
  31.               StorageLevel.MEMORY_AND_DISK_SER,  
  32.               tellMaster = true)  
  33.   
  34.           case None =>  
  35.             throw new SparkException("Failed to get " + pieceId + " of " + broadcastId)  
  36.         }  
  37.       }  
  38.       // If we get here, the option is defined.  
  39.       // 3.0 赋值数据块集合  
  40.       blocks(pid) = blockOpt.get  
  41.     }  
  42.     // 3.1 返回数据块  
  43.     blocks  
  44.   }</span>  

 
相关配置属性说明：
spark.broadcast.factory 定义使用http或Torrent方式，默认是Torrent，无需修改
spark.broadcast.blockSize 数据库块大小，blockifyObject依据此属性切分数据块，默认4M
spark.broadcast.compress 是否压缩，默认是使用，sparkcontext初始化该属性，无需修改

                                             
        0        0           
	
				
		









 海湾报警主机编程实例
    		海湾报警主机编程实例



原创粉丝点击



		

热门IT博客


呼叫转移软件呼叫转移软件




winhex恢复u盘数据winhex恢复u盘数据




java高级面试题2017




淘宝如何代销




天猫双十一各品类数据




淘宝最新搜索排名规则




nodejs高级编程 中文




金蝶软件连接数据库




大庆网络问政平台下载




公主坟软件培训




淘宝网客户端下载




centos svn 删除项目




同志软件有那些




java点餐系统源代码




tsardevel nginx




js设置input为只读




国际大数据产业博览会




儿童编程培训机构




win7禁止程序访问网络




php正则表达式匹配url



		

热门问题
    老师的惩罚
    人脸识别
    我在镇武司摸鱼那些年
    重生之率土为王
    我在大康的咸鱼生活
    盘龙之生命进化
    天生仙种
    凡人之先天五行
    春回大明朝
    姑娘不必设防，我是瞎子
    保洁小时工
    酒店保洁
    办公室保洁
    保洁价格
    专业保洁
    58保洁
    开荒保洁家庭保洁
    找保洁
    保洁保洁家庭
    工程保洁
    清洁保洁
    商场保洁
    石家庄保洁
    北京保洁
    东营保洁
    钟点工保洁
    汕头保洁
    小区保洁
    昆明保洁
    咸阳保洁
    新乡保洁
    厦门保洁
    烟台保洁
    济南保洁
    无锡保洁
    恩多保洁
    天津保洁
    通州保洁
    漯河保洁
    邢台保洁
    珠海保洁
    上门保洁
    家庭保洁保洁
    东莞保洁
    泰州保洁
    南阳保洁
    保洁工具
    保洁托管
    太原保洁
    南昌保洁
    保洁网站


	










程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里