package org.apache.flink.api.common.state;
import org.apache.flink.annotation.PublicEvolving;
/**
* Interface that different types of partitioned state must implement.
*
* <p>The state is only accessible by functions applied on a {@code KeyedStream}. The key is
* automatically supplied by the system, so the function always sees the value mapped to the key of
* the current element. That way, the system can handle stream and state partitioning consistently
* together.
*/
@PublicEvolving
public interface State {

/** Removes the value mapped under the current key. */
void clear();
}

@Internal
public interface Snapshotable<S extends StateObject> {
  
  /**
  * Operation that writes a snapshot into a stream that is provided by the given {@link
  * CheckpointStreamFactory} and returns a @{@link RunnableFuture} that gives a state handle to
  * the snapshot. It is up to the implementation if the operation is performed synchronous or
  * asynchronous. In the later case, the returned Runnable must be executed first before
  * obtaining the handle.
  *
  * @param checkpointId The ID of the checkpoint.
  * @param timestamp The timestamp of the checkpoint.
  * @param streamFactory The factory that we can use for writing our state to streams.
  * @param checkpointOptions Options for how to perform this checkpoint.
  * @return A runnable future that will yield a {@link StateObject}.
  */
  @Nonnull
  RunnableFuture<S> snapshot(
    long checkpointId,
    long timestamp,
    @Nonnull CheckpointStreamFactory streamFactory,
    @Nonnull CheckpointOptions checkpointOptions)
    throws Exception;
    }

State = 你正在編輯的 Word 文檔（內存中）
↓ 每隔一段時間
Checkpoint = 保存到磁盤的文檔副本（硬盤上）
↓ 如果程序崩潰
Recovery = 從最近的保存恢復（重新加載到內存）

/**
* Interface that combines both, the {@link KeyedStateBackend} interface, which encapsulates methods
* responsible for keyed state management and the {@link Snapshotable} which tells the system how to
* snapshot the underlying state.
*
* <p><b>NOTE:</b> State backends that need to be notified of completed checkpoints can additionally
* implement the {@link CheckpointListener} interface.
*
* @param <K> Type of the key by which state is keyed.
*/
public interface CheckpointableKeyedStateBackend<K>
extends KeyedStateBackend<K>, Snapshotable<SnapshotResult<KeyedStateHandle>>, Closeable {
  
  /** Returns the key groups which this state backend is responsible for. */
  KeyGroupRange getKeyGroupRange();
  /**
  * Returns a {@link SavepointResources} that can be used by {@link SavepointSnapshotStrategy} to
  * write out a savepoint in the common/unified format.
  */
  @Nonnull
  SavepointResources<K> savepoint() throws Exception;
    }

/**
* Base for the handles of the checkpointed states in keyed streams. When recovering from failures,
* the handle will be passed to all tasks whose key group ranges overlap with it.
*/
public interface KeyedStateHandle extends CompositeStateHandle {

/** Returns the range of the key groups contained in the state. */
KeyGroupRange getKeyGroupRange();
/**
* Returns a state over a range that is the intersection between this handle's key-group range
* and the provided key-group range.
*
* @param keyGroupRange The key group range to intersect with, will return null if the
*     intersection of this handle's key-group and the provided key-group is empty.
*/
@Nullable
KeyedStateHandle getIntersection(KeyGroupRange keyGroupRange);
/**
* Returns a unique state handle id to distinguish with other keyed state handles.