谈谈对 Flink 框架中容错机制及状态的一致性的理解

public class Test{    public static void main(String[] args) throws Exception{        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();        // 检查点的配置        // 开启检查点周期为毫秒        env.enableCheckpointing(300);        env.getCheckpointConfig().setCheckpointingMode(CheckpointingMode.EXACTLY_ONCE);        // 设置超时时间        env.getCheckpointConfig().setCheckpointTimeout(60000);        // 设置最大执行的checkp个数        env.getCheckpointConfig().setMaxConcurrentCheckpoints(2);        // 设置最小的间歇时间，两个checkpoint之间，前一次完成到后一次开始之间的间歇不能小于XXX        env.getCheckpointConfig().setMinPauseBetweenCheckpoints(100);        //env.getCheckpointConfig().setPreferCheckpointForRecovery();        // 容忍checkpoint失败多少次        env.getCheckpointConfig().setTolerableCheckpointFailureNumber(0);
        // 重启策略的配置        // 固定延时重启 每隔10秒进行一次重启尝试重启三次        env.setRestartStrategy(RestartStrategies.fixedDelayRestart(3,10000L));        // 失败率重启 在10分钟内统计重启，在10分钟内尝试三次重启，每次隔1分钟重启一次        env.setRestartStrategy(RestartStrategies.failureRateRestart(3, Time.minutes(10),Time.minutes(1)));
        DataStreamSource<String> inputStream = env.socketTextStream("localhost", 7777);        DataStream<SensorReading> dataStream = inputStream.map(line -> {            String[] fields = line.split(",");            return new SensorReading(fields[0], new Long(fields[1]), new Double(fields[2]));        });                env.execute();    }}

@Publicpublic enum CheckpointingMode {
  /**   * Sets the checkpointing mode to "exactly once". This mode means that the system will   * checkpoint the operator and user function state in such a way that, upon recovery,   * every record will be reflected exactly once in the operator state.   *   * <p>For example, if a user function counts the number of elements in a stream,   * this number will consistently be equal to the number of actual elements in the stream,   * regardless of failures and recovery.</p>   *   * <p>Note that this does not mean that each record flows through the streaming data flow   * only once. It means that upon recovery, the state of operators/functions is restored such   * that the resumed data streams pick up exactly at after the last modification to the state.</p>   *   * <p>Note that this mode does not guarantee exactly-once behavior in the interaction with   * external systems (only state in Flink's operators and user functions). The reason for that   * is that a certain level of "collaboration" is required between two systems to achieve   * exactly-once guarantees. However, for certain systems, connectors can be written that facilitate   * this collaboration.</p>   *   * <p>This mode sustains high throughput. Depending on the data flow graph and operations,   * this mode may increase the record latency, because operators need to align their input   * streams, in order to create a consistent snapshot point. The latency increase for simple   * dataflows (no repartitioning) is negligible. For simple dataflows with repartitioning, the average   * latency remains small, but the slowest records typically have an increased latency.</p>   */  EXACTLY_ONCE,
  /**   * Sets the checkpointing mode to "at least once". This mode means that the system will   * checkpoint the operator and user function state in a simpler way. Upon failure and recovery,   * some records may be reflected multiple times in the operator state.   *   * <p>For example, if a user function counts the number of elements in a stream,   * this number will equal to, or larger, than the actual number of elements in the stream,   * in the presence of failure and recovery.</p>   *   * <p>This mode has minimal impact on latency and may be preferable in very-low latency   * scenarios, where a sustained very-low latency (such as few milliseconds) is needed,   * and where occasional duplicate messages (on recovery) do not matter.</p>   */  AT_LEAST_ONCE}