RDD持久化、广播、累加器

所有的节点host配置一样，可以互相访问
命令：scp /etc/hosts root@node1:/etc/hosts(node1,2,3,4)
常用的Action：reduce，count，saveTextFile，foreach，countByKey
如果想在命令终端中看到执行结果，就必须Collect

凡是Action级别的操作都会触发sc.runJob

sc
val numbers=sc.parallelize
val numbers =sc.parallelize(1 to 100)
numbers.reduce(_+_)
val result=numbers.map(2*_)
val data=result.collect
numbers
1 to 100
numbers.count
val topN=numbers.take(5)
val scores=Array(Tuple2(1,100),Tuple2(2,100),Tuple2(3,100),Tuple2(1,100),)
val content=scores.paralelize//转化成RDD
val data=content.countBykey
sc.textFile("/root/javacount.sh").flapMap().map.reduceByKey.saveAsFile("")

RDD缓存情况：
1,某步骤计算特别耗时；
2，计算链条特别长的情况；
3，checkpoint所在的RDD也一定要持久化数据；
4，shuffle之后；网络传输，丢失重来
5，shuffle之前（框架默认帮助我们把数据持久化到本地磁盘）

StorageLevel
Memory_only_2在两台机器内存中缓存同样的东西，
Memory_only_ser节约内存，但是需要反序列化
MEMORY_AND_DISK主要是降低OOM的可能性

cache是persist的特例，只能缓存在内存
Cache之后一定不能立即有其它算子！

scala>sc.textFile("/data/putfile.txt").flatMap(_.split(" ")).map(word=> (word,1)).reduceByKey(_+_).count

scala>sc.textFile("/data/putfile.txt").flatMap(_.split(" ")).map(word=> (word,1)).reduceByKey(_+_).cache

scala>sc.textFile("/data/putfile.txt").flatMap(_.split(" ")).map(word=>(word,1)).reduceByKey(_+_).cache.count//此时变慢，主要是Cache之后一定不能立即有其它算子！

persist是lazy级别的
unpersist是eager级别的

为什么需要广播
大的变量：减少冗余，减少传输，每个task都要拷贝一份数据副本，一个excutor保存一份，（函数式编程，状态一致性，但耗内存）–》OOM
join：
shuffle：
同步：全局变量，只读，
广播是由Driver发给当前Application分配的所有Executor内存级别的全局只读变量，Executor中的线程池中的线程共享该全局变量，极大的减少了网络传输（否则的话每个Task都要传输一次该变量）并极大的节省了内存，当然也隐形的提高的CPU的有效工作
原因：每一task都需要一个全局变量，要是每个task都有一个全局变量的话，会产生OOM

val number =10
val broadcastNumber =sc.brodcast(number)//只能由sc广播

输出

org.apache.spark.broadcast.Broadcast[Int] = Broadcast(33)

val data=sc.parallelize(1 to 100)//task使用广播变量，所以要创建RDD
val bn = data.map(_* broadcastNumber.value)

累加器
Accumulator：对于Executor只能修改但不可读，只对Driver可读
记录集群状态，尤其全局唯一状态，
管理有点代价

val sum = sc.accumulator(0)
val data = sc.parallelize(0 to 5)
data.foreach(item => sum += item)
println(sum)

作业：
1.手动清除到persist内容
2。阅读累加器源码