Flink（四） 状态管理 1

最新推荐文章于 2024-06-09 19:39:29 发布
最新推荐文章于 2024-06-09 19:39:29 发布
阅读量1.1k 收藏 6
点赞数 1
分类专栏： 大数据 文章标签： flink
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44079636/article/details/119709182
版权

一、状态是什么？

1.1有状态和无状态：

  1. Flink不是要做流处理嘛。那当一个数据流过来的时候，第一个数据首先会被flink中的算子执行，执行完成 后会生成一个执行结果
  2. 这个执行后的结果，例如是输出一下，后续再过来的数据，例如第二个数据的计算就和第一个数据的计算毫无关系了，这就是无状态
  3. 这个执行后的结果。例如是需要做求和的计算，后续再过来的数据例如，的第二个数据的计算需要依赖与第一次计算的结果，这就是有状态的计算

1.2.Flink中的有状态流计算

1.2.1 flink中主要使用它的有状态计算
我们使用Flink这个技术主要也是来完成我们这些有状态 的计算的功能和任务的。因为 在流处理的过程中，很多场景下都需要使用前边一些数据的执行结果作为依赖进行后续的计算
1.2.2 具体的一些场景

  1. 筛选数据源过来的数据流中的一条条数据，看看是否是我们想要的格式，如果是就保存起来，如果不是就过滤掉
  2. 对一段时间内从数据源传过来的信息进行聚合分析，例如说统计10分钟内传过来的数据中大于80小于90之间的数据
  3. 对从数据源输入过 来的数据线进行记录 ，然后在进行去重等操作

上述的例子中都有个特点，就是将之前输入过来的数据进行保存，然后在对后续过来的数据 进行更新，这便是flink中的 有状态计算

1.3 Flink中状态的更新流程

状态的更新，说白了就是前面过来的数据的计算结果的更新，可以参考下面这个图来理解：

在这里插入图片描述

  1. 第一步数据从数据源的输入：receuve input
  2. 拿到了输入过来的数据后就要在Task中进行计算
  3. 然后就到了第二步，get state 得到了状态，也就是得到了上次计算完之后的结果，如果是第一次的话，就拿到了也是个空的
  4. 然后将这个结果保存起来,就是将计算结果更新到state中，既是第三步：update state
  5. 然后后续数据就又过来了，也是先在Task中计算，这时候这个第二条以及之后过来的数据他们 都要依赖于上一次计算的结果了，这时候执行的第二步就可以从拿到state，也就是拿到上次的计算的结果，然后在进行Task计算，计算完成后将计算的结果更新到state中，也就是途中的第三步：update state

二、状态分为哪些？

2.1两种分类方式：

  1. 按照类可以划分为Operator State算子状态和Keyed State键控状态
  2. 按照储存可以划分为：托管状态（Managed State）和原生状态（Raw State）

2.2 对于Operator State算子状态和Keyed State键控状态的进一步理解

1.首先说说这两种状态
每个状态（计算结果的数据）都是有当前任务完成的，自然也和当前算子关联在一起。那 Flink需要对 这些状态 进行管理首先 就得知道这些状态定义的 类型 是 什么类型吧，所以一开始就得注册相应的状态，也就是所谓的描述器。即Operator State算子状态和Keyed State键控状态
2.它们两个的区别：主要区别就是作用范围不一样

  1. 算子状态的作用范围就是限定为算子任务（也就是当前一个分区执行的时候，所有数据来了都能访问到状态）
  2. 键控状态中并不是当前分区所有的数据都能访问所有的状态，而是按照keyby之后的key做划分，当前key只能访问自己的状态

2.3 对于托管状态（Managed State）和原生状态（Raw State）的进一步理解

Keyed State以及Operator State都会以两种方式存储：managed和raw。

managed state指的是由Flink控制state的数据结构，比如使用内部hash表、RocksDB等。正是基于此，Flink可以更好地在managed state基础上进行内存优化和故障恢复。
raw state指的是Flink只知道state是一些字节数组，其余一无所知。需要用户自己完成state的序列化以及反序列化。因此，Flink不能基于raw state进行内存优化以及故障恢复。所以在企业实战中，很少使用raw state

两者的区别：

  1. Managed State是由Flink管理的，Flink帮忙存储、恢复和优化，
  2. Raw State是开发者自己管理的，需要自己序列化。

具体区别：

  1. 从状态管理的方式上来说，Managed State由Flink Runtime托管，状态是自动存储、自动恢复的，Flink在存储管理和持久化上做了一些优化。当横向伸缩，或者说修改Flink应用的并行度时，状态也能自动重新分布到多个并行实例上。Raw State是用户自定义的状态。
  2. 从状态的数据结构上来说，Managed State支持了一系列常见的数据结构，如ValueState、ListState、MapState等。Raw State只支持字节，任何上层数据结构需要序列化为字节数组。使用时，需要用户自己序列化，以非常底层的字节数组形式存储，Flink并不知道存储的是什么样的数据结构。
  3. 从具体使用场景来说，绝大多数的算子都可以通过继承Rich函数类或其他提供好的接口类，在里面使用Managed State。Raw State是在已有算子和Managed State不够用时，用户自定义算子时使用。

为了自定义Flink的算子，可以重写Rich Function接口类，比如RichFlatMapFunction。使用Keyed State时，通过重写Rich Function接口类，在里面创建和访问状态。对于Operator State，还需进一步实现CheckpointedFunction接口。

三、深入了解 Keyed State

3.1 简介

  1. 键控键控，键控状态肯定是相对于键来 进行管理 、维护和访问的
  2. Keyed State只能在KeyedStream后使用，Keyed State很类似于一个分布式的key-value map数据结构，只能用于KeyedStream（keyBy算子处理之后）。
  3. 键控状态基于每个key去管理，一般keyby进行HashCode重分区后基于它自己独享的内存空间就会针对每一个不同的key分别保存一份独立的存储状态，而且接下来来了一个新的数据只能访问自己的状态，不能访问其他key的，Flink会为每一个key维护一个状态。
  4. 每个状态都有clear()是清空操作。
  5. 在进行状态编程时需要通过RuntimeContext注册StateDescriptor。

如图：就是说有一堆数据过来了，首先 会根据key进行分组，分到哪就去执行哪的算子。比如说算子任务2，过来了一条数据，若是被分配到了算子任务二，你就呆在这里面，你所能访问的状态（以前计算的结果数据）也就只能是你们这一个算子任务的，若想访问算子任务一中的状态，对不起，不能

在这里插入图片描述

3.2 Flink 提供了以下数据格式来管理和存储键控状态 (Keyed State)：

  1. ValueState：存储单值类型的状态。可以使用 update(T) 进行更新，并通过 T value() 进行检索。
  2. ListState：存储列表类型的状态。可以使用 add(T) 或 addAll(List) 添加元素；并通过 get() 获得整个列表。
  3. ReducingState：用于存储经过 ReduceFunction 计算后的结果，使用 add(T) 增加元素。
  4. AggregatingState：用于存储经过 AggregatingState 计算后的结果，使用 add(IN) 添加元素。
  5. MapState：维护 Map 类型的状态。

小结如图：
在这里插入图片描述

3.3接下来就是在 Flink 中怎么 使用这些东西了

大致步骤如下：

  1. 通过dataStream.keyBy()获取到一个keyedStream
  2. keyedStream.map(自己写的方法)
  3. 定义这个自己 写的方法：基于状态完成数据的处理

3.4 然后主要内容就是如何根据需求不同怎么编写这个自定义类

大致步骤：

  1. 写一个类，继承RichMapFunction类
  2. 重写RichMapFunction里面的open方法。在open方法中，通过RuntimeContext对象的getXxxState(XxxStateDescriptor)方法获取到XxxState对象
  3. 实现RichMapFunction里面的map方法。 在map方法中，通过XxxState对象根据业务需要实现具体功能
  4. 在代码中的KeyedStream上使用自定义的MapFunction
3.4.1 需求：wordcount 。练习ValueState
import org.apache.flink.api.common.functions.{RichMapFunction, RuntimeContext}
import org.apache.flink.api.common.state.{ValueState, ValueStateDescriptor}
import org.apache.flink.api.java.tuple.Tuple
import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.scala._

/**
 * 通过wordcount功能，看ValueState的应用
 */
object ValueStateJob {
  def main(args: Array[String]): Unit = {
      //1.定义环境
    val environment: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
      //2.设置数据源
    val dataStream: DataStream[String] = environment.socketTextStream("192.168.229.10", 9999)
      //3.进行keyBy 得到keyedStream
    val keyedStream: KeyedStream[(String, Int), Tuple] = dataStream
      .flatMap(_.split(" "))
      .map((_, 1))
      .keyBy(0)

      //4.通过自定义方法实现状态的具体操作，完成数据的处理
    val result: DataStream[String] = keyedStream.map(new MyMapFunction)
      //5。打印输出
    result.print()
      //6.执行
    environment.execute("ValueStateJob")
  }

}
//两个类型参数，分别表示的是输入类型和输出类型
//输入类型：就是使用这个函数的keyedStream中的数据类型
//输出类型：是根据业务需要自己设置的类型
class MyMapFunction extends RichMapFunction[(String, Int),String]{
  //valueState中存储的是单词的个数
  var valueState:ValueState[Int]=_
    
  //open方法，用来做初始化的方法：只执行一次
  //在这个方法里面创建需要的状态对象
  override def open(parameters: Configuration): Unit = {
    //要创建状态对象，只需要通过RuntimeContext对象，提供的方法就可以把对象创建出来
    val runtimeContext: RuntimeContext = getRuntimeContext//通过RichMapFunction里面提供的方法getRuntimeContext可以获取到一个RuntimeContext对象
    //valueStateDescriptor:就是valueState的一个描述者，就是在这个里面声明ValueState中存储的数据的类型
    //两个参数分别表示：唯一标记以及状态中需要存储的数据的类型信息
    var valueStateDescriptor:ValueStateDescriptor[Int]=new ValueStateDescriptor[Int]("valueState",createTypeInformation[Int])
    valueState=runtimeContext.getState(valueStateDescriptor)//通过runtimeContext提供的getState方法可以获取一个ValueState对象

  }

  //value:就是输入（流）进来的数据;每流入进来一个元素都会执行一次这个方法
  override def map(value: (String, Int)): String = {
    //在这个方法中完成word count的计算
    //思路：首先从状态中把word对应的count获取到，然后加1,加完之后，再把最新的结果存入到状态中
    //1.通过valueState的value方法，获取到状态中存储的数据
    val oldCount: Int = valueState.value()
    //让原来的数据加1
    val newCount: Int = oldCount + value._2//也可以这样写：oldCount+1
    //2.通过valueState的update方法，把新计算的结果存入到状态中
    valueState.update(newCount)
    value._1+"==的数量是==>"+newCount
  }
}
3.4.2 需求：实现用户浏览商品类别统计 。练习ListState
import java.lang
import org.apache.flink.api.common.functions.RichMapFunction
import org.apache.flink.api.common.state.{ListState, ListStateDescriptor}
import org.apache.flink.api.java.tuple.Tuple
import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.scala._

import scala.collection.JavaConverters._

/**
 * 通过用户访问的类别
 * 业务系统发送过来的日志信息是这样的格式：用户编号  用户名  访问的类别名
 * 通过状态完成统计处理
 * 应该根据用户做统计（keyBy(用户)）；一个用户有可能会访问很多类别：应该使用ListState存储用户访问过的类别
 */
object ListStateJob {
  def main(args: Array[String]): Unit = {
    val environment: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    //模拟采集业务系统的日志信息；接下来测试的时候，就应该按照这种格式输入数据：用户编号 用户名 访问的类别
    val dataStream: DataStream[String] = environment.socketTextStream("192.168.229.10", 9999)
    val keyedStream: KeyedStream[(String, String, String), Tuple] = dataStream
      .map(_.split("\\s+"))
      .map(array => (array(0), array(1), array(2)))
      .keyBy(0)
    val result: DataStream[(String, String)] = keyedStream.map(new MyListStateMapFunction)
    result.print()
    environment.execute("ListStateJob")
  }
}
class MyListStateMapFunction extends RichMapFunction[(String, String, String),(String,String)]{
  var listState:ListState[String]=_
  override def open(parameters: Configuration): Unit = {
    listState=getRuntimeContext.getListState(new ListStateDescriptor[String]("lsd",createTypeInformation[String]))
  }

  override def map(value: (String, String, String)): (String, String) = {
    /*//根据业务需要，从状态中获取数据，然后处理数据，然后把数据在保存到状态中
    listState.add(value._3)//add方法就是往状态中添加一个数据
    //构建返回值
    //get方法，获取到状态中存储的数据
    val iter: lang.Iterable[String] = listState.get()
    val scalaIterable: Iterable[String] = iter.asScala//把java的Iterable转换成scala的Iterable
    val str: String = scalaIterable.mkString(",")//通过mkString方法，把iterable对象中的元素都通过逗号连接起来*/

    //考虑到去重：存储的数据就是已经去重的数据
    //1.从状态中数据获取到，把新进来的数据添加上，然后去重；然后再存入状态中
    val oldIterable: lang.Iterable[String] = listState.get()
    val scalaList: List[String] = oldIterable.asScala.toList
//    println(scalaList)
    val list: List[String] = scalaList :+ value._3//追加:
//    println(scalaList+"=========================")
    val distinctList: List[String] = list.distinct//去重
    listState.update(distinctList.asJava)//更新状态中的数据;upate方法需要一个util.list;所以应该通过asJava转换一下
    (value._1+":"+value._2,distinctList.mkString(" | "))
  }
}
3.4.3 需求： 统计用户浏览商品类别以及该类别的次数 。练习MapState
import org.apache.flink.api.common.functions.RichMapFunction
import org.apache.flink.api.common.state.{ListState, ListStateDescriptor, MapState, MapStateDescriptor}
import org.apache.flink.api.java.tuple.Tuple
import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.scala._

import scala.collection.JavaConverters._
/**
 * 通过MapState记录用户浏览的类别以及该类别对应的浏览次数
 */
object MapStateJob {
  def main(args: Array[String]): Unit = {
    /**
     * 1.2.3.4.5
     */
    val environment: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    //数据===》用户编号 用户名 所访问的类别
    val dataStream: DataStream[String] = environment.socketTextStream("192.168.229.10", 9999)
    //要处理，就应该根据用户分组===》根据用户做keyby
    val keyedStream: KeyedStream[(String, String), Tuple] = dataStream.map(_.split("\\s+"))
      .map(words => (words(0) + ":" + words(1), words(2)))
      .keyBy(0)
    val result: DataStream[String] = keyedStream.map(new MyMapMapFunction)
    result.print()
    environment.execute("MapStateJob")
  }
}
class MyMapMapFunction extends RichMapFunction[(String,String),String]{
  //通过MapState把用户访问的类别存储起来
  //mapState中的key是类别，value是该类别对应的访问次数
  var mapState:MapState[String,Int]=_
  override def open(parameters: Configuration): Unit = {
    mapState=getRuntimeContext.getMapState(new MapStateDescriptor[String,Int]("MapStateDescriptor",createTypeInformation[String],createTypeInformation[Int]))
  }
  override def map(value: (String, String)): String = {
    var category:String = value._2
    //如果类别已经访问过，访问次数就在原有基础上加1；如果没有访问过，就标记为1
    var count:Int=0
    if(mapState.contains(category)){
      count=mapState.get(category)
    }
    //把类别以及对应的访问次数放入到状态中
    mapState.put(category,count+1)
    //构建返回值
    val list: List[String] = mapState.entries().asScala.map(entry => entry.getKey + ":" + entry.getValue).toList
    val str: String = list.mkString(" | ")
    value._1+"--->"+str
  }
}
3.4.4 需求： 实现wordCount自动统计。练习ReducingState
import org.apache.flink.api.common.functions.{ReduceFunction, RichMapFunction, RuntimeContext}
import org.apache.flink.api.common.state.{ReducingState, ReducingStateDescriptor, ValueState, ValueStateDescriptor}
import org.apache.flink.api.common.typeinfo.TypeInformation
import org.apache.flink.api.java.tuple.Tuple
import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.scala._
/**
 * 通过ReducingState实现wordcount自动统计
 */
object ReducingStateJob {
  def main(args: Array[String]): Unit = {
    /**
     * 1.执行环境
     * 2.数据源：socket
     * 3.数据处理：
     *    3.1 flatmap
     *    3.2 map--->(word,1)
     *    3.3 keyby   ===>dataStream转换成了keyedStream
     *    3.4 map(new MyMapFunction)
     * 4.sink:print
     * 5.executeJob
     */
    /**
     * class MyMapFunction extends RichMapFunction
     * 通过valueState完成数据的统计处理
     * 1.在open方法中创建valueState对象
     *    a.需要RuntimeContext对象
     *
     *    b.RuntimeContext对象中提供的有方法，可以获取到ValueState
     * 2.在map方法中使用valueState对象
     */
    val environment: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    val dataStream: DataStream[String] = environment.socketTextStream("192.168.229.10", 9999)
    val keyedStream: KeyedStream[(String, Int), Tuple] = dataStream.flatMap(_.split("\\s+"))
      .map((_, 1))
      .keyBy(0)
    val result: DataStream[String] = keyedStream.map(new MyReducingMapFunction)
    result.print()
    environment.execute("ReducingStateJob")
  }
}
/**
 * In：输入数据的类型;根据使用这个函数的数据流（keyedStream）类型决定
 * Out：输出数据的类型；map方法的返回值类型。根据业务需要决定
 */
/*class MyMapFunction extends RichMapFunction[IN,Out]*/
class MyReducingMapFunction extends RichMapFunction[(String,Int),String]{
  //通过ReducingState完成wordcount 的自动统计
  var reducingState:ReducingState[Int]=_
  override def open(parameters: Configuration): Unit = {
    val context: RuntimeContext = getRuntimeContext
    val name:String="ReducingStateDescriptor"
    val typeInfo:TypeInformation[Int]=createTypeInformation[Int]
    val reduceFunction: ReduceFunction[Int] = new ReduceFunction[Int] {
      override def reduce(value1: Int, value2: Int): Int = {
//        print(value1+"****"+value2)
        value1+value2
      }
    }
    var reducingStateDescriptor:ReducingStateDescriptor[Int]=new ReducingStateDescriptor[Int](name,reduceFunction,typeInfo)
    reducingState=context.getReducingState(reducingStateDescriptor)
  }
  override def map(value: (String, Int)): String = {
    reducingState.add(value._2)//把需要计算的数据添加到reducingState里面
    value._1+":"+reducingState.get()
  }
}
3.4.5 需求：实现用户订单平均金额。练习AggeragetingState
import org.apache.flink.api.common.functions.{AggregateFunction, RichMapFunction}
import org.apache.flink.api.common.state.{AggregatingState, AggregatingStateDescriptor}
import org.apache.flink.api.common.typeinfo.TypeInformation
import org.apache.flink.api.java.tuple.Tuple
import org.apache.flink.configuration.Configuration
import org.apache.flink.streaming.api.scala._
object AggregatingStateJob {
  def main(args: Array[String]): Unit = {
    val environment: StreamExecutionEnvironment = StreamExecutionEnvironment.getExecutionEnvironment
    //要求输入的数据：  用户编号  用户名  订单金额
    val dataStream: DataStream[String] = environment.socketTextStream("192.168.229.10", 9999)
    val keyedStream: KeyedStream[(String, Double), Tuple] = dataStream.map(_.split("\\s+"))
      .map(words => (words(0) + ":" + words(1), words(2).toDouble))
      .keyBy(0)
    val result: DataStream[String] = keyedStream.map(new MyAggregateMapFunction)
    result.print()
    environment.execute("AggregatingStateJob")
  }
}

//通过aggregatingState完成订单的平均金额的计算
class MyAggregateMapFunction extends RichMapFunction[(String,Double),String]{
  //第一个Double表示的是订单金额；第二个Double表示的是用户的订单平均金额
  var aggregatingState:AggregatingState[Double,Double]=_
  override def open(parameters: Configuration): Unit = {
    //第一个Double:输入类型，就是订单金额
    //第二个类型（Double,Int）:中间类型，计算过程中的类型，表示（订单总金额,订单个数）
    //第三个类型Double:输出类型，就是订单平均金额
    var name:String="aggregatingStateDescriptor"
    var aggFunction:AggregateFunction[Double,(Double,Int),Double]=new AggregateFunction[Double,(Double,Int),Double] {
      override def createAccumulator(): (Double, Int) = (0,0)//初始值
      /**
       * 中间计算过程
       * @param value 输入数据，订单金额
       * @param accumulator 中间计算结果 (订单总金额,订单个数)
       * @return
       */
      override def add(value: Double, accumulator: (Double, Int)): (Double, Int) = (accumulator._1+value,accumulator._2+1)
      //计算结果
      override def getResult(accumulator: (Double, Int)): Double = accumulator._1/accumulator._2
      override def merge(a: (Double, Int), b: (Double, Int)): (Double, Int) = (a._1+b._1,a._2+b._2)
    }
    var accType:TypeInformation[(Double,Int)]=createTypeInformation[(Double,Int)]
    var aggregatingStateDescriptor:AggregatingStateDescriptor[Double,(Double,Int),Double]= new AggregatingStateDescriptor[Double,(Double,Int),Double](name,aggFunction,accType)
    aggregatingState=getRuntimeContext.getAggregatingState[Double,(Double,Int),Double](aggregatingStateDescriptor)
  
  override def map(value: (String, Double)): String = {
    aggregatingState.add(value._2)//把这一次订单的金额放进去
    val avg: Double = aggregatingState.get()//获取到状态中计算完成之后的订单平均金额
    value._1+"的订单平均金额："+avg
  }
}
小雨光
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
flink MapState 更新存储对象问题
cankan6204的博客
10-20 2194
这里写自定义目录标题欢迎使用Markdown编辑器 欢迎使用Markdown编辑器 在使用flink中的状态管理器时，由于需求背景我选用了MapState存储结构，但是在使用过程中发现修改存储对象的时候并没有MapState中的值并没有自动更新，这让我产生了很大的疑惑，看官方文档和flink源码中我都一直把MapState认为是类似于Map结构的，那自然认为修改里面的存储对象时整个map会自动更新，但是实际使用和测试下来确发现不是这样。 先贴一段官方文档： MapState<UK, UV>:
【状态管理｜概述】Flink的状态管理：为什么需要state、怎么保存state、对于state过大怎么处理
hiliang521的博客
10-16 2377
【状态管理｜概述】Flink的状态管理：为什么需要state、怎么保存state、对于state过大怎么处理
Flink 状态编程（一）状态的概念及特点
weixin_45417821的博客
04-24 1488
文章目录有状态算子状态的分类 在流处理中，数据是连续不断到来和处理的。每个任务进行计算处理时，可以基于当前数据直接转换得到输出结果；也可以依赖一些其他数据。这些由一个任务维护，并且用来计算输出结果的所有数据，就叫作这个任务的状态。 有状态算子 在 Flink 中，算子任务可以分为无状态和有状态两种情况。 无状态的算子任务只需要观察每个独立事件，根据当前输入的数据直接转换输出结果，例如，可以将一个字符串类型的数据拆分开作为元组输出；也可以对数据做一些计算，比如每个代表数量的字段加 1。如 map、filte
详解 Flink 的状态管理
最新发布
weixin_44480009的博客
06-09 1061
无状态的流处理：根据每一次当前输入的数据直接转换输出结果的过程，在处理中只需要观察每个输入的独立事件。例如， 将一个字符串类型的数据拆分开作为元组输出或将每个输入的数值加 1 后输出。Flink 中的基本转换算子 (map、filter、flatMap 等) 在计算时不依赖其他数据，所以都属于无状态的算子。有状态的流处理：根据每一次当前输入的数据和一些其他已处理的数据共同转换输出结果的过程，这些其他已处理的数据就称之为状态(state)，状态由任务维护，可以被任务的业务逻辑访问。
Flink 状态管理
mxk4869的博客
07-04 614
Flink 状态管理
Flink-状态管理
m0_57697768的博客
06-13 281
这样，并行度缩放之后的并行子任务就获取到了联合后完整的“大列表”，可以自行选择要使用的状态项和要丢弃的状态项。这种“均匀分配”的具体方法就是“轮询”（round-robin），与之前介绍的rebanlance数据传输方式类似，是通过逐一“发牌”的方式将状态项平均分配的。与Keyed State中的列表状态的区别是：在算子状态的上下文中，不会按键（key）分别处理状态，所以每一个并行子任务上只会保留一个“列表”（list），也就是当前并行子任务上所有状态项的集合。在这种情况下，状态的访问方式又会有所不同。
Flink---11、状态管理（按键分区状态（值状态、列表状态、Map状态、归约状态、聚合状态）算子状态（列表状态、广播状态））
星光不问赶路人，岁月不负有心人
10-08 2035
状态管理（按键分区状态（值状态、列表状态、Map状态、归约状态、聚合状态）算子状态（列表状态、广播状态））
Flink状态管理和检查点机制项目代码.rar
10-19
相对于其他流计算框架，Flink 一个比较重要的特性就是其支持有状态计算。即你可以将中间的计算结果进行保存，并提供给后续的计算使用： 具体而言，Flink 又将状态 (State) 分为 Keyed State 与 Operator State： ...
flink状态管理示例代码大全完整中文注释
10-19
在大数据处理领域，Apache Flink 是一个非常重要的流处理框架，以其高效、低延迟和强大的状态管理能力而闻名。本文将深入探讨Flink的状态管理，包括标题和描述中提到的关键概念，以及它们在实际应用中的作用。 首先...
Flink状态管理和恢复技术介绍1
08-04
在本文中，我们将深入探讨Apache Flink的状态管理和恢复技术，这是流处理框架中的核心组成部分。Flink的设计目标是提供高可用性和容错性，确保数据处理的准确性和一致性。 首先，理解Flink的状态至关重要。在处理流...
【Flink篇09】Flink之状态编程1
08-04
【Flink篇09】Flink之状态编程1 在大数据处理领域，Flink作为一款强大的流处理框架，其核心特性之一是有状态流处理。本文将深入探讨有状态流处理的概念、重要性以及Flink中如何实现和管理状态。 有状态流处理与无...
5_Flink的状态管理.pptx
07-14
flink 核心实例讲解及代码
Flink中状态
m0_37689903的博客
07-01 1409
本文介绍了Flink中的状态，主要是5种按键分区状态和3种算子状态以及状态的保存
Flink状态编程:为什么不建议在ValueState里面存Map？
南风知我意
06-18 322
Flink状态编程:为什么不建议在ValueState里面存Map？ RocksDB 场景，MapState 比 ValueState 中存 Map 性能高很多。 生产环境强烈推荐使用 MapState，不推荐 ValueState 中存大对象 ValueState 中存大对象很容易使 CPU 打满 Heap State 场景，两者性能类似。
【Flink】状态管理
lxtx
11-23 2521
根据当前的输入可以直接转换得到输出结果，这种鼻子就是无状态算子，如map,flatMap,filter。
Flink 流处理
qq_38634896的博客
08-09 1146
大数据 Flink 流处理
flink中 有状态计算（statefu）和无状态计算（stateless）的区别
Foools的博客
01-02 2026
一、有状态计算，无状态计算 apache flink来说，是支持有状态计算的。 无状态计算可以类比一下select操作，来一条，操作一条，数据不用留在系统里面。 有状态计算可以类比一下count，sum操作，这时候就需要缓存之前的数据，才可以实现，这样的计算就是有状态的。 ...
Flink 状态管理详解（超全收藏）
ytp552200ytp的博客
05-16 3673
Flink 状态管理详解（超全收藏）

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值