大数据学习day21-----spark04------1. 广播变量 2. RDD中的cache 3.RDD的checkpoint方法 4. 计算学科最受欢迎老师TopN
1. 广播变量
1.1 补充知识（来源：https://blog.csdn.net/huashetianzu/article/details/7821674）
之所以存在reduce side join，是因为在map阶段不能获取所有需要的join字段，即：同一个key对应的字段可能位于不同map中。Reduce side join是非常低效的，因为shuffle阶段要进行大量的数据传输。Map side join是针对以下场景进行的优化：两个待连接表中，有一个表非常大，而另一个表非常小，以至于小表可以直接存放到内存中。这样，我们可以将小表复制多份，让每个map task内存中存在一份（比如存放到hash table中），然后只扫描大表：对于大表中的每一条记录key/value，在hash table中查找是否有相同的key的记录，如果有，则连接后输出即可。为了支持文件的复制，Hadoop提供了一个类DistributedCache，使用该类的方法如下：（1）用户使用静态方法DistributedCache.addCacheFile()指定要复制的文件，它的参数是文件的URI（如果是HDFS上的文件，可以这样：hdfs://jobtracker:50030/home/XXX/file）。JobTracker在作业启动之前会获取这个URI列表，并将相应的文件拷贝到各个TaskTracker的本地磁盘上。（2）用户使用DistributedCache.getLocalCacheFiles()方法获取文件目录，并使用标准的文件读写API读取相应的文件。而对于spark而言，其提供广播变量的方法，是的每个executor中都会有一份小文件副本
1.2 广播变量的使用场景
通常是为了实现map-side join，可以将Driver端的数据广播到属于该application的Executor，然后通过Driver广播变量返回的引用，获取实现广播到Executor的数据
1.3 广播变量的实现原理
广播变量是通过BT的方式广播的（TorrentBroadcast），多个Executor（driver端的数据就会被分成多份数据分别广播至各个executor）可以相互传递数据，可以提高效率
sc.broadcast这个方法是阻塞的（同步的）
广播变量一但广播出去就不能改变（这是其缺点，因为实际应用中有时候是需要更新小文件的信息的，如spark03中1.3例子中 的ip规则数据），解决办法：为了以后可以定期的改变要关联的数据，可以定义一个object[单例对象]，在函数内使用，并且加一个定时器，然后定期更新数据（这种做法可以更新关联数据，但效率没有广播变量的方式高，spark03中1.3的例子用的就是这个方法，只是没有加一个定时器）
原理图（还是以spark03中1.3的案例为例）
步骤：
（1）每个task读取部分IP规则数据（使用sc.textFile（），有可能将数据读取到一个executor中）
（2）将IP规则数据收集到Driver端汇总
（3）将ip规则数据分成多份（视executor的个数定），使用TorrentBroadcast广播
（4）各个executor中的数据使用BT的方式互相传播，以至于每个executor中都有一份完整的ip规则数据
问题：是不是可以将task中读取到的数据不收集到driver端，直接在各个executor中互相传输
不可以，这些数据的传输是通过driver来控制的，不然各个executor不知道要怎么传输，传输给谁。
driver想要控制这些数据的互相传输，需要调用broadcast方法并且返回一个引用。以后driver端就可以通过这个引用找到事先广播好的数据
（5）读取ip日志信息（属于大数据）
（6）关联ip规则
问题：此处的运行在各个executor中的task如何找到ip规则数据进行关联操作的呢？
调用broadcast方法返回的引用随task一起被调度到executor中，所以task能找到广播好的数据。
案例 使用Spark读取日志文件，根据IP地址，查询日志文件中的IP地址对应的位置信息 ，并统计处各个省份的用户量（使用广播变量的形式）
代码如下（BroadcastIpRules）：
object BroadcastIpRules { def main(args: Array[String]): Unit = { // 决定是否在本地运行 val isLocal = args(0).toBoolean val conf: SparkConf = new SparkConf().setAppName(this.getClass.getSimpleName) if(isLocal){ conf.setMaster("local[*]") } //创建sparkcontext，用来创建rdd val sc: SparkContext = new SparkContext(conf) val ipLines: RDD[String] = sc.textFile(args(1)) // 加载并处理ip规则数据 val ipRulesRDD: RDD[(Long, Long, String, String)] = ipLines.map(ipLine => { val split: Array[String] = ipLine.split("\\|") val longStartIp: Long = split(2).toLong val longEndIp: Long = split(3).toLong val province: String = split(6) val city: String = split(7) (longStartIp, longEndIp, province, city) }) // 将ip规则数据收集到driver端 val ipRules: Array[(Long, Long, String, String)] = ipRulesRDD.collect() // 将driver端的ip规则数据广播到各个executor中,广播完成后返回各个executor中存储数据的地址引用 val ipRulesRef: Broadcast[Array[(Long, Long, String, String)]] = sc.broadcast(ipRules) // 读取日志信息文件 val logLines: RDD[String] = sc.textFile(args(2)) //处理要计算的数据并关联事先广播到Executor中的规则 val provinceRDD: RDD[(String, Int)] = logLines.map(logLine => { val split: Array[String] = logLine.split("\\|") val logIp: String = split(1) val ipNum: Long = IpUtils.ip2Long(logIp) // 通过广播返回的引用找到executor中的数据 val ipRulesInExecutor: Array[(Long, Long, String, String)] = ipRulesRef.value val index: Int = IpUtils.binarySearch(ipRulesInExecutor, ipNum) var province: String = "未知" if (index != -1) { province = ipRulesInExecutor(index)._3 } (province, 1) }) // 按照省份聚合 val res: RDD[(String, Int)] = provinceRDD.reduceByKey(_+_) //建计算结果保存到HDFS中 res.saveAsTextFile(args(3)) //释放资源 sc.stop() } }
此处采用在服务器的模式中运行
步骤：
（1）将上面代码打包，得到spark01-1.0-SNAPSHOT.jar形式的jar包
（2）并将这个jar包上传值需要运行的服务器上（此处我只上传到了master节点上）
（3）运行，命令如下：
/usr/apps/spark-2.3.3-bin-hadoop2.7/bin/spark-submit --class com._51doit.spark04.BroadcastIpRules --master spark://feng05:7077 --executor-memory 1g --total-executor-cores 4 spark01-1.0-SNAPSHOT.jar false hdfs://feng05:9000/ip/ip.txt hdfs://feng05:9000/data/ipaccess.log hdfs://feng05:9000/out2
广播变量做法的优缺点（较spark03中1.3的例子）
优点：
（1）使用广播变量实现mapside join，提升关联效率
（2）使用广播变量比单例对象加载规则数据效率更快
缺点：
广播出去的规则数据一旦广播后就无法修改
2. RDD中的cache和persist（来源：https://blog.csdn.net/sunspeedzy/article/details/69055072）
2.1 RDD的缓存级别
由以下源码可知，RDD有12中缓存级别
查看其构造函数
可以看到StorageLevel类的主构造器包含了5个参数：
- useDisk：使用硬盘
- useMemory：使用内存
- useOffHeap
使用堆外内存，这是Java虚拟机里面的概念，堆外内存意味着把内存对象分配在Java虚拟机的堆以外的内存，这些内存直接受操作系统管理（而不是虚拟机）。这样做的结果就是能保持一个较小的堆，以减少垃圾收集对应用的影响。
- deserialized
反序列化，其逆过程序列化（Serialization）是java提供的一种机制，将对象表示成一连串的字节；而反序列化就表示将字节恢复为对象的过程。序列化是对象永久化的一种机制，可以将对象及其属性保存起来，并能在反序列化后直接恢复这个对象。序列化方式存储对象可以节省磁盘或内存的空间，一般 序列化：反序列化=1:3
- replication：备份数（在多个节点上备份），默认是1份
理解了这5个参数，StorageLevel 的12种缓存级别就不难理解了。
val MEMORY_AND_DISK_SER_2 = new StorageLevel(true, true, false, false, 2) 就表示使用这种缓存级别的RDD将存储在硬盘以及内存中，使用序列化（在硬盘中），并且在多个节点上备份2份（正常的RDD只有一份）
2.2 Spark RDD Cache，persist
cache既算不上transformations算子也算不上Action算子，源码中并没有返回一个新的RDD
允许将RDD缓存到内存中或磁盘上， 以便于重用 。Spark提供了多种缓存级别， 以便于用户根据实际需求进行调整
cache和persist都是用于将一个RDD进行缓存的，这样在之后使用的过程中就不需要重新计算了，可以大大节省程序运行时间。
cache例子
persist例子
可见，放磁盘中比方catch慢，但比从hdfs中快
2.3 cache和persis的区别
基于spark2.3.3中的源码
从这段远吗可知。cache()调用了persist(),想要知道二者的不同，还需要看一下persist函数
可见persist方法内部调用了persist(StorageLevel.MEMORY_ONLY)方法，进一步查看此方法源码，如下
可以看出来persist有一个 StorageLevel 类型的参数，这个表示的是RDD的缓存级别。
至此便可得出cache和persist的区别了：cache只有一个默认的缓存级别MEMORY_ONLY ，而persist可以根据情况设置其它的缓存级别。
3.RDD的checkpoint方法
可以看的博客（https://blog.csdn.net/legotime/article/details/51290958）
当checkpoint为当前RDD设置检查点的时候，该函数将会创建一个二进制的文件，并存储到checkpoint目录中，该目录是用SparkContext.setCheckpointDir()设置的。在checkpoint的过程中，该RDD的所有依赖于父RDD中的信息将全部被移出。对RDD进行checkpoint操作并不会马上被执行，必须执行Action操作才能触发。当需要checkpoint的数据的时候，通过ReliableCheckpointRDD的readCheckpointFile方法来从file路径里面读出已经Checkpint的数据，然后加以应用
由于在checkpoint过程中，RDD的所有依赖于父RDD中的信息将全部被移出的特性，使用checkpoint前一遍都会使用catch，达到服用中间结果的目的。若是不cache，当一个rdd被checkpoint后，使用action将其触发后，其要先计算出原来已经有的结果，然后再将这个结果保存至hdfs，相当于有两个job。
例子
4. 计算学科最受欢迎老师TopN
需求：根据网站的行为日志，统计每个学科最受欢迎老师的TopN，即按照学科分组，在每一个组内进行排序
样例数据
4.1 实现方式一
调用groupBy按照学科进行分组，然后将value对应的迭代器toList，将数据全部加载到内存中，然后在调用List的sortBy方法进行排序，然后再调用take取TopN
object FavoriteTeacher { def main(args: Array[String]): Unit = { // 判断是否在本地运行 val isLocal: Boolean = args(0).toBoolean val conf: SparkConf = new SparkConf().setAppName(this.getClass.getSimpleName) if(isLocal){ conf.setMaster("local[*]") } // 创建SparkContext val sc: SparkContext = new SparkContext(conf) // 读取文件的信息，得到相应的RDD val teacherLines: RDD[String] = sc.textFile(args(1)) // 对数据进行切分，获取一些信息 val teacherAndSubjectRDD: RDD[((String, String), Int)] = teacherLines.map(line => { val split: Array[String] = line.split("/") val subject: String = split(2).split("\\.")(0) //获取科目信息 val teacher: String = split(3) ((subject, teacher), 1) }) // 聚合 val reducedRDD: RDD[((String, String), Int)] = teacherAndSubjectRDD.reduceByKey(_+_) // 按照学科进行分组 val grouped: RDD[(String, Iterable[((String, String), Int)])] = reducedRDD.groupBy(_._1._1) // 分组排序(降序) val topN = args(2).toInt val sorted: RDD[(String, List[((String, String), Int)])] = grouped.mapValues(_.toList.sortBy(-_._2).take(topN)) // 将数据收集到driver端，同时触发Action val res: Array[(String, List[((String, String), Int)])] = sorted.collect() println(res.toBuffer) sc.stop() } }
如果分组后，每一个组内的数量比较大，将迭代器toList会造成内存溢出，所以如果分组后组内的数据量比较大，这样的方式不适合。
4.2 实现方式二
上面先分组，再将每一个组对应的迭代器的数据toList后再排序，可能会出现内存溢出，所以现在使用的方式是先将每一个学科的数据单独过滤出来，然后调用RDD的sortBy方法进行排序，RDD的sortBy方法使用的是RangePartitioner，使用内存加磁盘进行排序，不会出现内存溢出。
代码如下
object FavoriteTeacher2 { def main(args: Array[String]): Unit = { // 判断是否在本地运行 val isLocal: Boolean = args(0).toBoolean val conf: SparkConf = new SparkConf().setAppName(this.getClass.getSimpleName) if(isLocal){ conf.setMaster("local[*]") } // 创建SparkContext val sc: SparkContext = new SparkContext(conf) // 读取文件的信息，得到相应的RDD val teacherLines: RDD[String] = sc.textFile(args(1)) // 对数据进行切分，获取一些信息 val teacherAndSubjectRDD: RDD[((String, String), Int)] = teacherLines.map(line => { val split: Array[String] = line.split("/") val subject: String = split(2).split("\\.")(0) //获取科目信息 val teacher: String = split(3) ((subject, teacher), 1) }) // 聚合 val reducedRDD: RDD[((String, String), Int)] = teacherAndSubjectRDD.reduceByKey(_+_) // 缓存 reducedRDD.cache() // 计算学科种类，并收集到driver端 val subjects: Array[String] = reducedRDD.map(_._1._1).distinct().collect() val topN = args(2).toInt for(subject <- subjects){ val filtered: RDD[((String, String), Int)] = reducedRDD.filter(t => t._1._1.equals(subject)) val res: Array[((String, String), Int)] = filtered.sortBy(_._2, false).take(topN) println(res.toBuffer) } // 释放资源（也会将cache释放掉） //reduced.unpersist(true) sc.stop() } }
4.3 实现方式三（自定义分区器）
实现方式二中使用的是默认的分区器，这种情况可能会出现多个学科数据被分到一个分区里（key中hashcode的值对下游分区数求余），如下图，这样这个分区对应的task就要处理更多的数据，不太好。解决办法：自己定义分区器，确保每个学科都被分到不同的分区中去。自己定义分区器要实现两点，（1）如何分区（即给定数据，其能知道分几个区，此处是按学科的种类数进行分区）（2）给定一个值能知道是哪一个分区（此处给定一个学科可以知道是属于哪个分区）
代码
object FavoriteTeacher03 { def main(args: Array[String]): Unit = { val isLocal = args(0).toBoolean //创建SparkConf，然后创建SparkContext val conf = new SparkConf().setAppName(this.getClass.getSimpleName) if (isLocal) { conf.setMaster("local[*]") } val sc = new SparkContext(conf) //指定以后从哪里读取数据创建RDD val lines: RDD[String] = sc.textFile(args(1)) //对数据进行切分 val subjectTeacherAndOne = lines.map(line => { val fields = line.split("/") val subject = fields(2).split("[.]")(0) val teacher = fields(3) ((subject, teacher), 1) }) //聚合 val reduced: RDD[((String, String), Int)] = subjectTeacherAndOne.reduceByKey(_+_) //全局排序，我想要的是分组TopN //val sorted = reduced.sortBy(_._2, false) //将reduced cache到内存 reduced.cache() //计算所有的学科，并收集到Driver端 val subjects: Array[String] = reduced.map(_._1._1).distinct().collect() //paritioner是在Driver端被new出来的，但是他的方法是在Executor中被调用的 val partitioner = new SubjectPartitioner(subjects) //reduced使用指定的分区器对数据进行分区 val partitionedRDD: RDD[((String, String), Int)] = reduced.partitionBy(partitioner) //将每一个分区中的数据进行处理 val result = partitionedRDD.mapPartitions(it => it.toList.sortBy(-_._2).take(2).iterator) //触发Action，打印 val r = result.collect().toBuffer println(r) sc.stop() } } // 使用class而不是object，以后每个task都可能需要自己的分区器，使用object就变成单例的了 class SubjectPartitioner(val subjects: Array[String]) extends Partitioner { //初始化分器的分区规则 val rules = new mutable.HashMap[String, Int]() var index = 0 for(sub <- subjects) { rules(sub) = index index += 1 } override def numPartitions: Int = subjects.length //该方法会在Executor中的Task中被调用 override def getPartition(key: Any): Int = { val tuple = key.asInstanceOf[(String, String)] val subject = tuple._1 //到实现初始化的规则中查找这个学科对应的分区编号 rules(subject) } }
此方法可能也会发生内存溢出，即将迭代器toList的时候（当一个分区的数据足够大）
四. 实现方式四
实现方式3还有个明显的缺点，即需要shuffle的地方太多，有三处，如下
解决办法，reduceByKey有一个重载的方法，可以传入一个分区器，在数据聚合的时候就可以实现按特定分区器进行分区的目的
代码如下
package com._51doit.spark04 import org.apache.spark.rdd.RDD import org.apache.spark.{Partitioner, SparkConf, SparkContext} import scala.collection.mutable object FavoriteTeacher4 { def main(args: Array[String]): Unit = { val isLocal = args(0).toBoolean //创建SparkConf，然后创建SparkContext val conf = new SparkConf().setAppName(this.getClass.getSimpleName) if (isLocal) { conf.setMaster("local[*]") } val sc = new SparkContext(conf) //指定以后从哪里读取数据创建RDD val lines: RDD[String] = sc.textFile(args(1)) //对数据进行切分 val subjectTeacherAndOne = lines.map(line => { val fields = line.split("/") val subject = fields(2).split("[.]")(0) val teacher = fields(3) ((subject, teacher), 1) }) //计算所有的学科，并收集到Driver端 val subjects: Array[String] = subjectTeacherAndOne.map(_._1._1).distinct().collect() //paritioner是在Driver端被new出来的，但是他的方法是在Executor中被调用的 val partitioner = new SubjectPartitioner2(subjects) //根据指定的key和分区器进行聚合(减少一次shuffle) val reduced: RDD[((String, String), Int)] = subjectTeacherAndOne.reduceByKey(partitioner, _+_) val topN = args(2).toInt val result = reduced.mapPartitions(it => { //定义好一个排序规则 implicit val sortRules: Ordering[((String, String), Int)] = Ordering[Int].on[((String, String), Int)](t => -t._2) //定义一个key排序的集合TreeSet val sorter = new mutable.TreeSet[((String, String), Int)]() //遍历出迭代器中的数据 it.foreach(t => { sorter += t if (sorter.size > topN) { val last = sorter.last //移除最后一个 sorter -= last } }) sorter.iterator }) val r = result.collect() println(r.toBuffer) sc.stop() } } class SubjectPartitioner2(val subjects: Array[String]) extends Partitioner { //初始化分器的分区规则 val rules = new mutable.HashMap[String, Int]() var index = 0 for(sub <- subjects) { rules(sub) = index index += 1 } override def numPartitions: Int = subjects.length //该方法会在Executor中的Task中被调用 override def getPartition(key: Any): Int = { val tuple = key.asInstanceOf[(String, String)] val subject = tuple._1 //到实现初始化的规则中查找这个学科对应的分区编号 rules(subject) } }
此处值得学习的代码
此处用到的on方法，如下
其相当于new Ordering[((String, String), Int)]，完整写法应该如下
implicit val sortRules: Ordering[((String, String), Int)] = new Ordering[((String, String), Int)] { override def compare(x: ((String, String), Int), y: ((String, String), Int)): Int = { y._2-x._2 } }
