pyspark distinct去重

Spark Streaming 架构:
    1,Spark Streaming为每个输入源启动对应的接收器。接收器以任务的形式运行在应用的执行器进程中，从输入源收集数据并保存为 RDD。
    2,收集到输入数据后会把数据复制到另一个执行器进程来保障容错性(默 认行为)。数据保存在执行器进程的内存中，和缓存 RDD 的方式一样。
    3,驱动器程序中的 StreamingContext 会周期性地运行 Spark 作业来处理这些数据，把数据与之前时间区间中的 RDD 进行整合。
    4,每个接收器都以 Spark 执行器程序中一个长期运行的任务的形式运行，因此会占据分配给应用的 CPU 核心。
    5,我们还需要有可用的 CPU 核心来处理数据。这意味着如果要运行多个接收器，就必须至少有和接收器数目相同的核心数，还要加上用来完成计算所需要的核心数(最少一个)。

自定义 接收器

package Day3

import java.io.{BufferedReader, InputStreamReader}
import java.net.Socket

import org.apache.spark.storage.StorageLevel
import org.apache.spark.streaming.receiver.Receiver

class Streaming_(host: String, port:Int) extends Receiver[String](StorageLevel.MEMORY_ONLY){
  // 接收器启动的时候调用
  override def onStart(): Unit = {
    // 接收器是线程来实现的
    new Thread("receiver"){
      override def run(): Unit = {
        print("---------------------")
        // 接受数据提交给 框架
        receive()
      }
    }.start()
  }
  def receive(): Unit ={
    var sockt:Socket = null
    var input:String = null
    try{
      // 使用 Socket 监听端口
      sockt = new Socket(host,port)
      // 生成输入流
      val reader = new BufferedReader(new InputStreamReader(sockt.getInputStream))

//      // 数据传递给 executor
//      store(input)
      while (!isStopped()&& (input=reader.readLine())!=null){
        store(input)
        input=reader.readLine()
      }
      restart("restart")

    }catch {
      case e:java.net.ConnectException => restart("restart")
      case t:Throwable => restart("restart")
    }
  }
  // 接收器关闭调用
  override def onStop(): Unit = {

  }
}

使用无状态接收器(没有使用自定义接收器)

package Day3
import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Seconds, StreamingContext}
object Wc {
  def main(args: Array[String]): Unit = {
      val conf = new SparkConf().setMaster("local[*]").setAppName("wc")
      val ssc = new StreamingContext(conf,Seconds(5))
      //接受的数据方式,返回的是一行一行的数据, 接受 master:9999 端口
      val lineDstream = ssc.socketTextStream("master",9999)
      val wordsDstream = lineDstream.flatMap(_.split(" "))
      val k2vDstream = wordsDstream.map((_,1))
      val results = k2vDstream.reduceByKey(_+_)
      results.print()
      // 开启 Stream 启动消息采集和处理
      ssc.start()
    /*
    -------------------------------------------
    Time: 1561649120000 ms
    -------------------------------------------
    (da,1)
    (DA,1)
    (ad,2)
    (AD,3)
    */
      ssc.awaitTermination()
  }}

使用有状态接收器,实际使用了 checkpoint 保存了上次 状态

package Day3
import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Seconds, StreamingContext}
object Wc {
    def main(args: Array[String]): Unit = {
        val conf = new SparkConf().setMaster("local[2]").setAppName("wc")
        val ssc = new StreamingContext(conf,Seconds(5))
        ssc.checkpoint("./check")
        //接受的数据方式,返回的是一行一行的数据, 接受 master:9999 端口
        //      val lineDstream = ssc.socketTextStream("master",9999)
        // 使用自定义的接收器
        val lineDstream = ssc.receiverStream(new Streaming_("master",9999))
        val wordsDstream = lineDstream.flatMap(_.split(" "))
        val k2vDstream = wordsDstream.map((_,1))
        val updateFuc = (v:Seq[Int],state:Option[Int])=>{
            val preStatus = state.getOrElse(0)
            Some(preStatus+v.sum)
        }
        val results = k2vDstream.updateStateByKey(updateFuc)
        results.print()
        // 开启 Stream 启动消息采集和处理
        ssc.start()
        /*
-------------------------------------------
Time: 1561799425000 ms
-------------------------------------------
(4,1)
(ss,1)
(55,1)
(2,1)
(,3)
(s,8)
(234,1)
(3,3)
(q,3)
(12,1)
...
        */
        ssc.awaitTermination()
    }}

/*
SparkStreaming是准实时的处理框架（微批处理）,按照时间段进行收集数据
以上代码运行说明

* */

以上代码运行说明

使用 Window Operations 来获取 Streaming运行状态

package Day3
import org.apache.spark.SparkConf
import org.apache.spark.streaming.{Seconds, StreamingContext}
object Wc {
    def main(args: Array[String]): Unit = {
        val conf = new SparkConf().setMaster("local[2]").setAppName("wc")
        val ssc = new StreamingContext(conf,Seconds(5))
        ssc.checkpoint("./check")
        //接受的数据方式,返回的是一行一行的数据, 接受 master:9999 端口
        //      val lineDstream = ssc.socketTextStream("master",9999)
        // 使用自定义的接收器
        val lineDstream = ssc.receiverStream(new Streaming_("master",9999))
        val wordsDstream = lineDstream.flatMap(_.split(" "))
        val k2vDstream = wordsDstream.map((_,1))
//        val updateFuc = (v:Seq[Int],state:Option[Int])=>{
//            val preStatus = state.getOrElse(0)
//            Some(preStatus+v.sum)
//        }
//        val results = k2vDstream.updateStateByKey(updateFuc)

        // 使用窗口函数 (reduce 函数,窗口大小,步长)
      //  每次重新计算,重复的部分删掉
//         val results = k2vDstream.reduceByKeyAndWindow((x:Int,y:Int)=>x+y,Seconds(15),Seconds(10))

      // 使用窗口函数 (reduce 函数,减去多余的(前五秒的),窗口大小,步长)
      // 这种方式更加优化，针对重复次数来计算
        val results = k2vDstream.reduceByKeyAndWindow((x:Int,y:Int)=>x+y,(a:Int,b:Int)=>a-b,Seconds(15),Seconds(10))
        results.print()
        // 开启 Stream 启动消息采集和处理
        ssc.start()
        /*
-------------------------------------------
Time: 1561866450000 ms
-------------------------------------------
(2,8)
(,1)
(22,1)
(1,3)
*/
        ssc.awaitTermination()
    }}

以上代码运行说明