org.apache.flink.streaming.api

枚举 TimeCharacteristic

java.lang.Object

java.lang.Enum<TimeCharacteristic>

org.apache.flink.streaming.api.TimeCharacteristic

所有已实现的接口:

Serializable, Comparable<TimeCharacteristic>

@PublicEvolving
public enum TimeCharacteristic
extends Enum<TimeCharacteristic>

The time characteristic defines how the system determines time for time-dependent order and operations that depend on time (such as time windows).

枚举常量概要

枚举常量

枚举常量和说明
EventTime Event time means that the time of each individual element in the stream (also called event) is determined by the event's individual custom timestamp.
IngestionTime Ingestion time means that the time of each individual element in the stream is determined when the element enters the Flink streaming data flow.
ProcessingTime Processing time for operators means that the operator uses the system clock of the machine to determine the current time of the data stream.

方法概要

限定符和类型	方法和说明
static TimeCharacteristic	valueOf(String name) 返回带有指定名称的该类型的枚举常量。
static TimeCharacteristic[]	values() 按照声明该枚举类型的常量的顺序, 返回 包含这些常量的数组。

从类继承的方法 java.lang.Enum

clone, compareTo, equals, finalize, getDeclaringClass, hashCode, name, ordinal, toString, valueOf

从类继承的方法 java.lang.Object

getClass, notify, notifyAll, wait, wait, wait

枚举常量详细资料

ProcessingTime

public static final TimeCharacteristic ProcessingTime

Processing time for operators means that the operator uses the system clock of the machine to determine the current time of the data stream. Processing-time windows trigger based on wall-clock time and include whatever elements happen to have arrived at the operator at that point in time.

Using processing time for window operations results in general in quite non-deterministic results, because the contents of the windows depends on the speed in which elements arrive. It is, however, the cheapest method of forming windows and the method that introduces the least latency.

IngestionTime

public static final TimeCharacteristic IngestionTime

Ingestion time means that the time of each individual element in the stream is determined when the element enters the Flink streaming data flow. Operations like windows group the elements based on that time, meaning that processing speed within the streaming dataflow does not affect windowing, but only the speed at which sources receive elements.

Ingestion time is often a good compromise between processing time and event time. It does not need any special manual form of watermark generation, and events are typically not too much out-or-order when they arrive at operators; in fact, out-of-orderness can only be introduced by streaming shuffles or split/join/union operations. The fact that elements are not very much out-of-order means that the latency increase is moderate, compared to event time.

EventTime

public static final TimeCharacteristic EventTime

Event time means that the time of each individual element in the stream (also called event) is determined by the event's individual custom timestamp. These timestamps either exist in the elements from before they entered the Flink streaming dataflow, or are user-assigned at the sources. The big implication of this is that it allows for elements to arrive in the sources and in all operators out of order, meaning that elements with earlier timestamps may arrive after elements with later timestamps.

Operators that window or order data with respect to event time must buffer data until they can be sure that all timestamps for a certain time interval have been received. This is handled by the so called "time watermarks".

Operations based on event time are very predictable - the result of windowing operations is typically identical no matter when the window is executed and how fast the streams operate. At the same time, the buffering and tracking of event time is also costlier than operating with processing time, and typically also introduces more latency. The amount of extra cost depends mostly on how much out of order the elements arrive, i.e., how long the time span between the arrival of early and late elements is. With respect to the "time watermarks", this means that the cost typically depends on how early or late the watermarks can be generated for their timestamp.

In relation to IngestionTime, the event time is similar, but refers the the event's original time, rather than the time assigned at the data source. Practically, that means that event time has generally more meaning, but also that it takes longer to determine that all elements for a certain time have arrived.

方法详细资料

values

public static TimeCharacteristic[] values()

按照声明该枚举类型的常量的顺序, 返回 包含这些常量的数组。该方法可用于迭代 常量, 如下所示:

for (TimeCharacteristic c : TimeCharacteristic.values())
    System.out.println(c);

返回:

按照声明该枚举类型的常量的顺序返回的包含这些常量的数组

valueOf

public static TimeCharacteristic valueOf(String name)

返回带有指定名称的该类型的枚举常量。 字符串必须与用于声明该类型的枚举常量的 标识符完全匹配。(不允许有多余 的空格字符。)

参数:

name - 要返回的枚举常量的名称。

返回:

返回带有指定名称的枚举常量

抛出:

IllegalArgumentException - 如果该枚举类型没有带有指定名称的常量

NullPointerException - 如果参数为空值