Flink 1.17教程：任务槽Task Slots和并行度的关系

爱被打了一巴掌 2023-10-15 14:39 44阅读 0赞

## 任务槽Task Slots ##

在 Apache Flink 中，任务槽（Task Slots）是指可用于执行并行任务的资源单元。每个任务槽可以看作是一个可用的执行线程或处理单元，用于并行执行作业的不同部分。

通俗来说，可以将任务槽想象成一个工作台，而每个工作台上都可以同时进行一项任务。任务槽的数量决定了同时可以执行的任务数量。

任务槽的作用和应用场景：

1.  并行执行：任务槽允许在同一时刻并行执行多个任务。每个任务槽可以独立地执行一个任务或算子，从而有效地利用计算资源，提高作业的并行度和整体处理能力。
2.  任务分配和负载均衡：任务槽可以用于将不同的任务或算子分配到不同的资源上。通过合理分配任务槽，可以实现负载均衡，确保任务在可用资源之间均匀分配，避免资源浪费和瓶颈。
3.  容错和高可用性：任务槽还可以提供容错和高可用性。如果一个任务槽上的任务或算子失败，系统可以将其重新分配到其他可用的任务槽上，从而实现故障恢复和保证作业的持续执行。

总的来说，任务槽在 Apache Flink 中扮演着并行执行任务的角色，可以提高作业的并行度和整体处理能力。它们用于任务分配、负载均衡以及容错和高可用性的实现。

![img][]

## 任务槽的共享组 ##

![img][img 1]

默认情况下，Flink是允许子任务共享slot的。如果我们保持sink任务并行度为1不变，而作业提交时设置全局并行度为6，那么前两个任务节点就会各自有6个并行子任务，整个流处理程序则有13个子任务。如上图所示，只要属于同一个作业，那么对于不同任务节点（算子）的并行子任务，就可以放到同一个slot上执行。所以对于第一个任务节点source→map，它的6个并行子任务必须分到不同的slot上，而第二个任务节点keyBy/window/apply的并行子任务却可以和第一个任务节点共享slot。

package com.atguigu.wc;
     
    import org.apache.flink.api.common.typeinfo.Types;
    import org.apache.flink.api.java.tuple.Tuple2;
    import org.apache.flink.configuration.Configuration;
    import org.apache.flink.streaming.api.datastream.DataStreamSource;
    import org.apache.flink.streaming.api.datastream.SingleOutputStreamOperator;
    import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
    import org.apache.flink.util.Collector;
     
    /**
     * TODO DataStream实现Wordcount：读socket（无界流）
     *
     * @author
     * @version 1.0
     */
    public class SlotSharingGroupDemo {
        
        public static void main(String[] args) throws Exception {
        
            // TODO 1.创建执行环境
    		// StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
            // IDEA运行时，也可以看到webui，一般用于本地测试
            // 需要引入一个依赖 flink-runtime-web
            StreamExecutionEnvironment env = StreamExecutionEnvironment.createLocalEnvironmentWithWebUI(new Configuration());
     
            // 在idea运行，不指定并行度，默认就是 电脑的 线程数
            env.setParallelism(1);
     
            // TODO 2.读取数据：socket
            DataStreamSource<String> socketDS = env.socketTextStream("hadoop102", 7777);
     
            // TODO 3.处理数据: 切换、转换、分组、聚合
            SingleOutputStreamOperator<Tuple2<String,Integer>> sum = socketDS
                    .flatMap(
                            (String value, Collector<String> out) -> {
        
                                String[] words = value.split(" ");
                                for (String word : words) {
        
                                    out.collect(word);
                                }
                            }
                    )
                    .returns(Types.STRING)
                    .map(word -> Tuple2.of(word, 1)).slotSharingGroup("aaa")
                    .returns(Types.TUPLE(Types.STRING,Types.INT))
                    .keyBy(value -> value.f0)
                    .sum(1);
     
     
            // TODO 4.输出
            sum.print();
     
            // TODO 5.执行
            env.execute();
        }
    }
     
    /**
     1、slot特点：
        1）均分隔离内存，不隔离cpu
        2）可以共享：
              同一个job中，不同算子的子任务 才可以共享 同一个slot，同时在运行的前提是，属于同一个 slot共享组，默认都是“default”
     2、slot数量 与 并行度 的关系
        1）slot是一种静态的概念，表示最大的并发上限
           并行度是一种动态的概念，表示 实际运行 占用了 几个
        2）要求： slot数量 >= job并行度（算子最大并行度），job才能运行
           TODO 注意：如果是yarn模式，动态申请
             --> TODO 申请的TM数量 = job并行度 / 每个TM的slot数，向上取整
           比如session： 一开始 0个TaskManager，0个slot
             --> 提交一个job，并行度10
                --> 10/3，向上取整，申请4个tm，
                --> 使用10个slot，剩余2个slot
     */

## slot与并行度的关系&演示 ##

### 任务槽和并行度的关系 ###

任务槽和并行度都跟程序的并行执行有关，但两者是完全不同的概念。简单来说任务槽是静态的概念，是指`TaskManager`具有的并发执行能力，可以通过参数`taskmanager.numberOfTaskSlots`进行配置；而并行度是动态概念，也就是`TaskManager`运行程序时实际使用的并发能力，可以通过参数`parallelism.default`进行配置。

1、slot特点：  
1）均分隔离内存，不隔离cpu  
2）可以共享：  
同一个job中，不同算子的子任务 才可以共享 同一个slot，同时在运行的前提是，属于同一个 slot共享组，默认都是“default”  
2、slot数量 与 并行度 的关系  
1）slot是一种静态的概念，表示最大的并发上限  
并行度是一种动态的概念，表示 实际运行 占用了 几个  
2）要求： slot数量 >= job并行度（算子最大并行度），job才能运行  
注意：如果是yarn模式，动态申请  
\--> 申请的TM数量 = job并行度 / 每个TM的slot数，向上取整  
比如session： 一开始 0个TaskManager，0个slot  
\--> 提交一个job，并行度10  
\--> 10/3，向上取整，申请4个tm，  
\--> 使用10个slot，剩余2个slot

并行度是指在作业执行过程中同时执行的任务或算子的数量。它决定了作业可以同时处理多少个数据分片或并行操作。并行度可以在作业级别、算子级别或子任务级别进行设置。

任务槽则是实际的执行资源单元，用于并行执行任务或算子。每个任务槽可以看作一个可用的执行线程或处理单元。

关系如下：

1.  并行度和任务槽数量：并行度通常与任务槽的数量相关联。如果并行度大于任务槽的数量，那么任务将被分配到多个任务槽中执行，从而实现并行处理。如果并行度小于或等于任务槽的数量，那么每个任务或算子可以在一个单独的任务槽中执行。
2.  负载均衡：任务槽的数量可以用于实现任务的负载均衡。如果并行度大于任务槽的数量，系统会尽量将任务均匀分配到可用的任务槽中，以实现资源的充分利用和负载的平衡。
3.  容错性：任务槽的数量也与容错性相关。如果某个任务槽上的任务或算子失败，系统可以将其重新分配到其他可用的任务槽上，从而实现故障恢复和保证作业的持续执行。

综上所述，任务槽和并行度密切相关，任务槽提供了实际的执行资源单元，用于并行执行任务或算子。并行度决定了同时执行的任务或算子的数量，而任务槽的数量可以影响并行度的设置、负载均衡和容错性。

[img]: https://img-blog.csdnimg.cn/5533aafc346a4ebe8c1b1ad14e44573d.png
[img 1]: https://img-blog.csdnimg.cn/82f423d2949a4a37990205284e3cf32f.png