【Flink】任务调度原理、自定义数据源、基本转换算子的使用之map

一 Flink运行架构

1 任务调度原理

（1）TaskManger与Slots

Flink中每一个worker(TaskManager)都是一个JVM进程，它可能会在独立的线程上执行一个或多个subtask。为了控制一个worker能接收多少个task，worker通过task slot来进行控制（一个worker至少有一个task slot）。

每个task slot表示TaskManager拥有资源的一个固定大小的子集。假如一个TaskManager有三个slot，那么它会将其管理的内存分成三份给各个slot。资源slot化意味着一个subtask将不需要跟来自其他job的subtask竞争被管理的内存，取而代之的是它将拥有一定数量的内存储备。需要注意的是，这里不会涉及到CPU的隔离，slot目前仅仅用来隔离task的受管理的内存。

通过调整task slot的数量，允许用户定义subtask之间如何互相隔离。如果一个TaskManager一个slot，那将意味着每个task group运行在独立的JVM中（该JVM可能是通过一个特定的容器启动的），而一个TaskManager多个slot意味着更多的subtask可以共享同一个JVM。而在同一个JVM进程中的task将共享TCP连接（基于多路复用）和心跳消息。它们也可能共享数据集和数据结构，因此这减少了每个task的负载。

默认情况下，Flink允许子任务共享slot，即使它们是不同任务的子任务（前提是它们来自同一个job）。 这样的结果是，一个slot可以保存作业的整个管道。

Task Slot是静态的概念，是指TaskManager具有的并发执行能力**，可以通过参数taskmanager.numberOfTaskSlots进行配置；而**并行度parallelism是动态概念，即TaskManager运行程序时实际使用的并发能力，可以通过参数parallelism.default进行配置。

也就是说，假设一共有3个TaskManager，每一个TaskManager中的分配3个TaskSlot，也就是每个TaskManager可以接收3个task，一共9个TaskSlot，如果我们设置parallelism.default=1，即运行程序默认的并行度为1，9个TaskSlot只用了1个，有8个空闲，因此，设置合适的并行度才能提高效率。

并行度的设置见以下程序：

public static void main(String[] args) throws Exception{
    StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
    // 整体并行度设置为1
    env.setParallelism(1);

    // 设置局部并行度为1
    DataStreamSource<String> stream = env.fromElements("hello word", "hello word").setParallelism(1);

    // 设置局部并行度为2
    SingleOutputStreamOperator<WordWithCount> mappedStream = stream
            .flatMap(new FlatMapFunction<String, WordWithCount>() {
                public void flatMap(String value, Collector<WordWithCount> out) throws Exception {
                    String[] arr = value.split(" ");
                    for (String s : arr) {
                        out.collect(new WordWithCount(s, 1L));
                    }
                }
            }).setParallelism(2);

    // 分组：按照key进行分区，与并行度无关
    KeyedStream<WordWithCount, String> keyedStream = mappedStream
            .keyBy(new KeySelector<WordWithCount, String>() {
                public String getKey(WordWithCount value) throws Exception {
                    return value.word;
                }
            });

    // 设置局部并行度为2
    SingleOutputStreamOperator<WordWithCount> result = keyedStream
            .reduce(new ReduceFunction<WordWithCount>() {
                public WordWithCount reduce(WordWithCount value1, WordWithCount value2) throws Exception {
                    return new WordWithCount(value1.word, value1.count + value2.count);
                }
            }).setParallelism(2);

    // 设置局部并行度为1
    result.print().setParallelism(1);

    env.execute("Socket stream word count");
}

针对每个算子设置并行度的优先级高于全局并行度。

fromElements并行度为1，只会占用一个任务槽。

flatMap并行度为2，会占用两个任务槽。

reduce并行度为2，会占用两个任务槽。

print并行度为1，只会占用一个任务槽。

综上，整个程序会占用两个任务槽。

动态并行度插槽的大小不能超过任务插槽的数量，超过会报错NoResourceAvailableException。

四个可以设置并行度地方的优先级：程序中的算子并行度 > 程序中的全局并行度 > 命令行提交时可以设置并行度（flink run -p 2） > 配置文件中有默认并行度。

并行度设置原则：针对算子设置并行度，不要设置全局并行度，可以方便我们进行动态扩容。

（2）程序与数据流（DataFlow）

所有的Flink程序都是由三部分组成的： Source 、Transformation和Sink。

Source负责读取数据源，Transformation利用各种算子进行处理加工，Sink负责输出。

在运行时，Flink上运行的程序会被映射成“逻辑数据流”（dataflows），它包含了这三部分。每一个dataflow以一个或多个sources开始以一个或多个sinks结束。dataflow类似于任意的有向无环图（DAG）。在大部分情况下，程序中的转换运算（transformations）跟dataflow中的算子（operator）是一一对应的关系，但有时候，一个transformation可能对应多个operator。

（3）图数据结构的转化

由Flink程序直接映射成的数据流图是StreamGraph，也被称为逻辑流图，因为它们表示的是计算逻辑的高级视图。为了执行一个流处理程序，Flink需要将逻辑流图转换为物理数据流图（也叫执行图），详细说明程序的执行方式。

Flink 中的执行图可以分成四层：StreamGraph -> JobGraph -> ExecutionGraph -> 物理执行图。

StreamGraph：是根据用户通过 Stream API 编写的代码生成的最初的图。用来表示程序的拓扑结构，顶点是各种算子，使用边将各种算子结合起来。

JobGraph：StreamGraph经过优化后生成了 JobGraph，提交给 JobManager 的数据结构。主要的优化为，将多个符合条件（窄依赖，没有shuffle）的算子 chain 在一起作为一个节点，这样可以本地转发，减少数据在节点之间流动所需要的序列化/反序列化/传输消耗。只用相同并行度且one to one操作的算子才可以进行聚合成为一个节点（见下文）。

ExecutionGraph：JobManager 根据 JobGraph 生成ExecutionGraph。ExecutionGraph是JobGraph的并行化版本，是调度层最核心的数据结构。

物理执行图：JobManager 根据 ExecutionGraph 对 Job 进行调度后，在各个TaskManager 上部署 Task 后形成的“图”，并不是一个具体的数据结构，只存在我们的想象中，是一个有向有环图。

（4）并行度（Parallelism）

Flink程序的执行具有并行、分布式的特性。

在执行过程中，一个流（stream）包含一个或多个分区（stream partition），而每一个算子（operator）可以包含一个或多个子任务（operator subtask），这些子任务在不同的线程、不同的物理机或不同的容器中彼此互不依赖地执行。

一个特定算子的子任务（subtask）的个数被称之为其并行度（parallelism）。一般情况下，一个流程序的并行度，可以认为就是其所有算子中最大的并行度。一个程序中，不同的算子可能具有不同的并行度。

图的转换如下图：

Stream在算子之间传输数据的形式可以是one-to-one(forwarding)的模式也可以是redistributing的模式，具体是哪一种形式，取决于算子的种类。

One-to-one：stream(比如在source和map operator之间)维护着分区以及元素的顺序。那意味着map 算子的子任务看到的元素的个数以及顺序跟source 算子的子任务生产的元素的个数、顺序相同，map、fliter、flatMap等算子都是one-to-one的对应关系。类似于spark中的窄依赖

Redistributing：stream(map()跟keyBy/window之间或者keyBy/window跟sink之间)的分区会发生改变。每一个算子的子任务依据所选择的transformation发送数据到不同的目标任务。例如，keyBy() 基于hashCode重分区、broadcast和rebalance会随机重新分区，这些算子都会引起redistribute过程，而redistribute过程就类似于Spark中的shuffle过程。 类似于spark中的宽依赖。

在上图中，ABD并行度相同且都是向前传输，可以在一个任务槽中执行；CD之间存在shuffle；DE并行度不相同，所以两个D的输出最终会有集合在一起的操作。

（5）任务链（Operator Chains）

相同并行度的one to one操作，Flink这样相连的算子链接在一起形成一个task，原来的算子成为里面的一部分。将算子链接成task是非常有效的优化：它能减少线程之间的切换和基于缓存区的数据交换，在减少时延的同时提升吞吐量。链接的行为可以在编程API中进行指定。

二 Flink DataStream API

1 自定义数据源

在生产环境中一般不会自定义数据源，flink的数据一般来源于kafka。

源码如下：

package day02;

import org.apache.flink.streaming.api.datastream.DataStreamSource;
import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.streaming.api.functions.source.ParallelSourceFunction;
import org.apache.flink.streaming.api.functions.source.SourceFunction;

import java.sql.Timestamp;
import java.util.Calendar;
import java.util.Random;

/**
 * 自定义数据源
 */
public class Example1 {
    public static void main(String[] args) throws Exception{
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        // 事件驱动型程序，当开始执行任务的时候，会触发run()，点击cancel按钮时，会触发cancel()方法
        // 不需要实例化ClickSource对象，然后对象.run 对象.cancel主动调用
        DataStreamSource<Event> stream = env.addSource(new ClickSource());

        stream.print();

        env.execute();
    }

    // 实现一个接口，泛型是数据流里面元素的类型
    // SourceFunction是单并行度接口，并行度只能为1
    // 自定义并行化版本的数据源，需要使用ParallelSourceFunction
    public static class ClickSource implements SourceFunction<Event> {

        private boolean running = true;
        private String[] userArr = {"Marry","Bob","Alice","liz"};
        private String[] urlArr = {"./home","./cart","./fav","./prob?id=1","./prob?id=2"};
        private Random random = new Random();

        @Override
        public void run(SourceContext<Event> ctx) throws Exception {
            // 无限向下游发送数据
            while (running){
                ctx.collect(
                        new Event(
                              userArr[random.nextInt(userArr.length)],
                              urlArr[random.nextInt(urlArr.length)],
                              Calendar.getInstance().getTimeInMillis()
                        )
                );
                Thread.sleep(1000L);
            }
        }

        @Override
        public void cancel() {
            running = false;
        }
    }

    // 数据源的类型--POJO类
    public static class Event{
        public String user;
        public String url;
        public Long timestamp;

        public Event() {
        }

        public Event(String user, String url, Long timestamp) {
            this.user = user;
            this.url = url;
            this.timestamp = timestamp;
        }

        @Override
        public String toString() {
            return "Event{" +
                    "user='" + user + '\'' +
                    ", url='" + url + '\'' +
                    ", timestamp=" + new Timestamp(timestamp) +
                    '}';
        }
    }
}

2 基本转换算子的使用

基本转换算子的定义：作用在数据流中的每一条单独的数据上的算子。基本转换算子会针对流中的每一个单独的事件做处理，也就是说每一个输入数据会产生一个输出数据。单值转换，数据的分割，数据的过滤，都是基本转换操作的典型例子。

单流的转化包括：map，filter，flatMap，实际上就是它会针对一条流上的数据做转换。

（1）map

a 使用匿名函数的方式

public class Example2 {
    public static void main(String[] args) throws Exception{
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        env.setParallelism(1);

        env
                .addSource(new SourceFunction<Integer>() {
                    private boolean running = true;
                    private Random random = new Random();
                    @Override
                    public void run(SourceContext<Integer> ctx) throws Exception {
                        while (running){
                            ctx.collect(random.nextInt(1000));
                            Thread.sleep(1000L);
                        }
                    }

                    @Override
                    public void cancel() {
                        running = false;
                    }
                })
                .map(r -> r * r)
                .print();

        env.execute();
    }
}

b 使用匿名类的方式

                .map(new MapFunction<Integer, Tuple2<Integer,Integer>>(){
                    @Override
                    public Tuple2<Integer, Integer> map(Integer value) throws Exception {
                        return Tuple2.of(value,value*2);
                    }
                })
                .print();

c 使用外部类的方式

        .map(new MyMap())
        .print();

public static class MyMap implements MapFunction<Integer,Tuple2<Integer,Integer>>{

    @Override
    public Tuple2<Integer, Integer> map(Integer integer) throws Exception {
        return Tuple2.of(integer,integer);
    }
}

d 需要类型推断的地方要提示程序

可以认为java的类型推断系统没有scala实现的强大，scala可以完成自动推断。

The return type of function ‘main(Example2.java:32)’ could not be determined automatically, due to type erasure. You can give type information hints by using the returns(…) method on the result of the transformation call, or by letting your function implement the ‘ResultTypeQueryable’ interface.

.map(r -> Tuple2.of(r,r))
.returns(Types.TUPLE(Types.INT,Types.INT))
.print();

类型擦除：Tuple2.of(r,r)会被擦除成Tuple2<Object,Object>，需要使用returns方法标注一下map函数的输出类型。

JVM在已知返回值数据类型的时候，如c，也会进行类型擦除成Object，但是由于直到类型，所以JVM又进行了强制类型转换。

e 使用flatMap实现map

flatMap是map的泛化（底层）实现。

.flatMap(new FlatMapFunction<Integer, Tuple2<Integer,Integer>>() {
    @Override
    public void flatMap(Integer integer, Collector<Tuple2<Integer, Integer>> collector) throws Exception {
        collector.collect(Tuple2.of(integer,integer));
    }
})
.print();