【Flink】Flink的分区策略及源码分析

一：Flink的分区策略

    在Flink的应用中，每个算子都可以设置并行度，比如上游的Map算子的并行度为3，而下游filter的算子并行度为4，那当上下游算子并行度不一致的情况下，
flink怎么传递数据呢，这就涉及到Flink的分区策略

二：Flink的分区关键类源码分析

 Flink 中分区策略中有一个抽象类StreamPartitioner，源码如下：

public abstract class StreamPartitioner<T> implements
		ChannelSelector<SerializationDelegate<StreamRecord<T>>>, Serializable {
	private static final long serialVersionUID = 1L;
    
	protected int numberOfChannels;

	@Override
	public void setup(int numberOfChannels) {
		this.numberOfChannels = numberOfChannels;
	}

	@Override
	public boolean isBroadcast() {
		return false;
	}

	public abstract StreamPartitioner<T> copy();
}

如上面源码可是看出StreamPartitioner 实现了ChannelSelector 接口，下面我们对接口进行分析，其代码如下：

public interface ChannelSelector<T extends IOReadableWritable> {
    //初始化channels数量，channel可以理解为下游Operator的某个实例(并行算子的某个subtask).
    void setup(int var1);
    //根据当前的record以及Channel总数，决定应将record发送到下游哪个Channel;不同的分区策略会实现不同的该方法。
    int selectChannel(T var1);
    //是否以广播的形式发送到下游所有的算子实例
    boolean isBroadcast();
}

故所有的分区类都实现了上面的三个方法，我们查看了继承了StreamPartitioner的分区具体类如下图所示：

如上图所示具体实现类有下面，并具体对每个类进行分析

• GlobalPartitioner
• ShufflePartitioner
• RebalancePartitioner
• RescalePartitioner
• BroadcastPartitioner
• ForwardPartitioner
• KeyGroupStreamPartitioner
• CustomPartitionerWrapper

GlobalPartitioner:  其源码如下——无论下游算子的并行度为多少，都会把数据路由到第一subtask中

public class GlobalPartitioner<T> extends StreamPartitioner<T> {
	private static final long serialVersionUID = 1L;

	//该分区器会将所有的数据都发送到下游的某个算子实例(subtask id = 0)
	public int selectChannel(SerializationDelegate<StreamRecord<T>> record) {
		return 0;
	}

	@Override
	public StreamPartitioner<T> copy() {
		return this;
	}

	@Override
	public String toString() {
		return "GLOBAL";
	}
}

ShufflePartitioner：其源码如下——随机选个subtask把数据路由下去

@Internal
public class ShufflePartitioner<T> extends StreamPartitioner<T> {
	private static final long serialVersionUID = 1L;

	private Random random = new Random();

	@Override
	public int selectChannel(SerializationDelegate<StreamRecord<T>> record) {
		 //随机选择channel
         return random.nextInt(numberOfChannels);
	}

	@Override
	public StreamPartitioner<T> copy() {
		return new ShufflePartitioner<T>();
	}

	@Override
	public String toString() {
		return "SHUFFLE";
	}
}

RebalancePartitioner：其代码实现如下———其会循环把数据分配到下游的subtask中,均匀分区；

@Internal
public class RebalancePartitioner<T> extends StreamPartitioner<T> {
	private static final long serialVersionUID = 1L;

	private int nextChannelToSendTo;

	@Override
	public void setup(int numberOfChannels) {
		super.setup(numberOfChannels);
        //初始化channel的id，返回[0,numberOfChannels)的伪随机数
		nextChannelToSendTo = ThreadLocalRandom.current().nextInt(numberOfChannels);
	}

	@Override
	public int selectChannel(SerializationDelegate<StreamRecord<T>> record) {
		//循环依次发送到下游的task，比如：nextChannelToSendTo初始值为0，numberOfChannels(下游算子的实例个数，并行度)值为2
        //则第一次发送到ID = 1的task，第二次发送到ID = 0的task，第三次发送到ID = 1的task上...依次类推
        nextChannelToSendTo = (nextChannelToSendTo + 1) % numberOfChannels;
		return nextChannelToSendTo;
	}

	public StreamPartitioner<T> copy() {
		return this;
	}

	@Override
	public String toString() {
		return "REBALANCE";
	}
}

RescalePartitioner：其实现代码如下——分区元素循环到下游操作的子集。如果您希望拥有管道，例如，从源的每个并行实例扇出到多个映射器的子集以分配负载但又不希望发生rebalance（）会产生完全重新平衡，那么这非常有用。这将仅需要本地数据传输而不是通过网络传输数据，具体取决于其他配置值，例如TaskManagers的插槽数。
上游操作发送元素的下游操作的子集取决于上游和下游操作的并行度。例如，如果上游操作具有并行性2并且下游操作具有并行性4，则一个上游操作将元素分配给两个下游操作，而另一个上游操作将分配给另外两个下游操作。另一方面，如果下游操作具有并行性2而上游操作具有并行性4，那么两个上游操作将分配到一个下游操作，而另外两个上游操作将分配到其他下游操作。在不同并行度不是彼此的倍数的情况下，一个或多个下游操作将具有来自上游操作的不同数量的输入。

public class RescalePartitioner<T> extends StreamPartitioner<T> {
	private static final long serialVersionUID = 1L;

	private int nextChannelToSendTo = -1;

	@Override
	public int selectChannel(SerializationDelegate<StreamRecord<T>> record) {
		if (++nextChannelToSendTo >= numberOfChannels) {
			nextChannelToSendTo = 0;
		}
		return nextChannelToSendTo;
	}

	public StreamPartitioner<T> copy() {
		return this;
	}

	@Override
	public String toString() {
		return "RESCALE";
	}
}

BroadcastPartitioner: 其实现代码如下————数据会发到下游的每个subtasks,比如下游有两个subtask,那数据两个subtask 都会发送

public class BroadcastPartitioner<T> extends StreamPartitioner<T> {
	private static final long serialVersionUID = 1L;

	/**
	 * Note: Broadcast mode could be handled directly for all the output channels
	 * in record writer, so it is no need to select channels via this method.
	 */
	@Override
	public int selectChannel(SerializationDelegate<StreamRecord<T>> record) {
		throw new UnsupportedOperationException("Broadcast partitioner does not support select channels.");
	}

	@Override
	public boolean isBroadcast() {
		return true;
	}

	@Override
	public StreamPartitioner<T> copy() {
		return this;
	}

	@Override
	public String toString() {
		return "BROADCAST";
	}
}

ForwardPartitioner：其源码实现如下——ForwardPartitioner,FORWARD分区。将记录输出到下游本地的operator实例。ForwardPartitioner分区器要求上下游算子并行度一样。上下游Operator同属一个SubTasks。

public class ForwardPartitioner<T> extends StreamPartitioner<T> {
	private static final long serialVersionUID = 1L;

	@Override
	public int selectChannel(SerializationDelegate<StreamRecord<T>> record) {
		return 0;
	}

	public StreamPartitioner<T> copy() {
		return this;
	}

	@Override
	public String toString() {
		return "FORWARD";
	}
}

KeyGroupStreamPartitioner： 其代码实现如下————根据key传递下去

public class KeyGroupStreamPartitioner<T, K> extends StreamPartitioner<T> implements ConfigurableStreamPartitioner {
	private static final long serialVersionUID = 1L;

	private final KeySelector<T, K> keySelector;

	private int maxParallelism;


	@Override
	public int selectChannel(SerializationDelegate<StreamRecord<T>> record) {
		K key;
		try {
			key = keySelector.getKey(record.getInstance().getValue());
		} catch (Exception e) {
			throw new RuntimeException("Could not extract key from " + record.getInstance().getValue(), e);
		}
		return KeyGroupRangeAssignment.assignKeyToParallelOperator(key, maxParallelism, numberOfChannels);
	}


	@Override
	public String toString() {
		return "HASH";
	}


}

CustomPartitionerWrapper：

 

 

 

 

补充和借鉴资源文档https://zhuanlan.zhihu.com/p/165907184