1-1、Partitioner 简介
1-1、Partitioner 简介
一、Partitioner简介
Partitioner的作用是对Mapper产生的中间结果进行分片，以便将同一个分组的数据交给同一个Reducer处理，它直接影响Reducer阶段的复杂均衡。
Partitioner只提供了一个方法：
getPartition(Text key,Text value,int numPartitions)
前两个参数是Map的Key和Value，numPartitions为Reduce的个数。
源码可以看到是一个抽象类，只包含一个抽象方法：
|
public abstract class Partitioner<KEY, VALUE> {
/**
* Get the partition number for a given key (hence record) given the total
* number of partitions i.e. number of reduce-tasks for the job.
*
* <p>Typically a hash function on a all or a subset of the key.</p>
*
* @param key the key to be partioned.
* @param value the entry value.
* @param numPartitions the total number of partitions.
* @return the partition number for the <code>key</code>.
*/
public abstract int getPartition(KEY key, VALUE value, int numPartitions);
}
|
Partitioner的工作原理。如下图：
Partitioner有两个功能：
1、均衡负载：尽量将工作均匀地分配给不同的Reduce；
2、效率：分配速度一定要快；
二、MapReduce提供的Partitioner的实现
MapReduce提供了4种Partitioner，默认是HashPartitioner，如下图：
Partitioner是一个基类，如果定制Partitioner需要继承该类：
2.1、HashPartitioner是MapReduce的默认Partitioner：
源码如下所示：
|
/** Partition keys by their {@link Object#hashCode()}. */
@InterfaceAudience.Public
@InterfaceStability.Stable
public class HashPartitioner<K, V> extends Partitioner<K, V> {
/** Use {@link Object#hashCode()} to partition. */
public int getPartition(K key, V value,
int numReduceTasks) {
return (key.hashCode() & Integer.MAX_VALUE) % numReduceTasks;
}
}
|
如源码所示，计算方法为：
which reducer=(key.hashCode() & Integer.MAX_VALUE ) % numReduceTasks
取key的hashCode码与Integer的最大值做按位与运算，得出的结果和Reducer的个数取模，最终将这个Key发送到相应Reducer上面。
Integer.MAX_VALUE表示int类型能够表示的最大值，
.hashCode()表示返回哈希值
.hashCode()表示返回哈希值
&是按位与运算符
2.2、BinaryPartitioner继承于Partitioner<BinaryComparable,V>,是Partitioner的字节码子类。
该类提供 leftOffset 和 rightOffset ，在计算which reducer时，仅对Key-Value中的Key的[rightOffset ,leftOffset ]区间取hash。
which reducer=(hash & Integer.MAX_VALUE) % numPartitions;
部分源码：
|
public class BinaryPartitioner<V> extends Partitioner<BinaryComparable, V>
implements Configurable {
public static final String LEFT_OFFSET_PROPERTY_NAME =
"mapreduce.partition.binarypartitioner.left.offset";
public static final String RIGHT_OFFSET_PROPERTY_NAME =
"mapreduce.partition.binarypartitioner.right.offset";
public static void setOffsets(Configuration conf, int left, int right) {
conf.setInt(LEFT_OFFSET_PROPERTY_NAME, left);
conf.setInt(RIGHT_OFFSET_PROPERTY_NAME, right);
}
public static void setLeftOffset(Configuration conf, int offset) {
conf.setInt(LEFT_OFFSET_PROPERTY_NAME, offset);
}
public static void setRightOffset(Configuration conf, int offset) {
conf.setInt(RIGHT_OFFSET_PROPERTY_NAME, offset);
}
@Override
public int getPartition(BinaryComparable key, V value, int numPartitions) {
int length = key.getLength();
int leftIndex = (leftOffset + length) % length;
int rightIndex = (rightOffset + length) % length;
int hash = WritableComparator.hashBytes(key.getBytes(),
leftIndex, rightIndex - leftIndex + 1);
return (hash & Integer.MAX_VALUE) % numPartitions;
}
}
|
2.3、KeyFieldBasedPartitioner是基于hash的Partitioner。与BinaryPartitioner不同的是，它提供了多个区间用于计算hash。
当区间数为0时，KeyFieldBashdPartitioner就变成了HashPartitioner。
部分源码：
|
public class KeyFieldBasedPartitioner<K2, V2> extends Partitioner<K2, V2>
implements Configurable {
private static final Log LOG = LogFactory.getLog(
KeyFieldBasedPartitioner.class.getName());
public static String PARTITIONER_OPTIONS =
"mapreduce.partition.keypartitioner.options";
private int numOfPartitionFields;
public int getPartition(K2 key, V2 value, int numReduceTasks) {
byte[] keyBytes;
List <KeyDescription> allKeySpecs = keyFieldHelper.keySpecs();
if (allKeySpecs.size() == 0) {
return getPartition(key.toString().hashCode(), numReduceTasks);
}
try {
keyBytes = key.toString().getBytes("UTF-8");
} catch (UnsupportedEncodingException e) {
throw new RuntimeException("The current system does not " +
"support UTF-8 encoding!", e);
}
// return 0 if the key is empty
if (keyBytes.length == 0) {
return 0;
}
int []lengthIndicesFirst = keyFieldHelper.getWordLengths(keyBytes, 0,
keyBytes.length);
int currentHash = 0;
for (KeyDescription keySpec : allKeySpecs) {
int startChar = keyFieldHelper.getStartOffset(keyBytes, 0,
keyBytes.length, lengthIndicesFirst, keySpec);
// no key found! continue
if (startChar < 0) {
continue;
}
int endChar = keyFieldHelper.getEndOffset(keyBytes, 0, keyBytes.length,
lengthIndicesFirst, keySpec);
currentHash = hashCode(keyBytes, startChar, endChar,
currentHash);
}
return getPartition(currentHash, numReduceTasks);
}
protected int hashCode(byte[] b, int start, int end, int currentHash) {
for (int i = start; i <= end; i++) {
currentHash = 31*currentHash + b[i];
}
return currentHash;
}
protected int getPartition(int hash, int numReduceTasks) {
return (hash & Integer.MAX_VALUE) % numReduceTasks;
}
}
|
2.4、TotalOrderPartitioner类可以实现输出额全排序。不同于以上3个Partitioner，这个类不是基于hash的。
每一个Reduce的输出在默认情况下都是有顺序的，但是Reduce之间在输入是无序的情况下也是无序的。如果要实现输出是全排序的，
就要用到TotalOrderPartitioner。
要使用TotalOrderPartitioner，需要给TotalOrderPartitioner提供一个partition file。这个文件要求key(这些key就是所谓的划分)的数量和当前Reducer的数量减一相同，并且是从小到大排序。
TotalOrderPartitioner对不同的Key的数据类型提供两种方案：
1、对于非BinaryComparable类型的Key，TotalOrderPartitioner采用二分法查找当前的Key所在的index。
例如Reducer的数量是5，partition file提供4个划分为[2,4,6,8]。如果当前的一个Key-Value值是<4,"good">，利用二分法查找到index=1，index+1=2，那么这个Key-Value值将会发送到第二个Reduce。如果一个Key-Value值为<4.5,"good">,那么二分查找将返回-3，同样对-3加一然后取反就是这个Key-Value值将要去的Reducer。 对于一些数值型的数据来说，利用二分法查找复杂度o(log(reducer count))速度比较快。
2、对于BinaryComparable类型的key(也可以直接理解为字符串)。字符串按照字典顺序也是可以进行排序的。
这样的话也可以给定一些划分，让不同的字符串Key分配到不同的Reduce里。这里的处理和数值类型比较相近。例如Reducer的数量是5，partition file提供4个划分为["abc","bce","eaa","fhc"]，那么"ab"这个字符串将会被分配到第一个Reducer里，因为它小于第一个划分"abc"。但是不同于数值型的数据，字符串的查找和比较不能按照数值型数据的比较方法。MapReduce采用Tire Tree的字符串查找方法。查找的时间复杂度为o(m)，m为树的深度，空间复杂度o(255^m-1)。Tire Tree的字符串查找是一个典型的空间换时间的案例。
三、自定义分区
MyPartitionerPar的功能是把Map端输出的Key为"hadoop"发送给reduce-0处理，结果存在part-r-00000里面；Key为"storm"发送给reduce-1处理，结果存在part-r-00001里面；Key为"spark"发送给reduce-2处理，结果存在part-r-00002里面。
四、采集器 Sampler
Hadoop自带的采集器(Sample)也是基于Partitioner实现的，是一种海量数据排序的算法。
Hadoop自带的Sample可以对输入目录下的数据进行采样。提供了如下3种采样方法：
输入采样一般在对海量数据进行排序的时候用的比较多，主要是用来缓解Reduce端的负载均衡，Hadoop自带的1TB的数据排序算法就用到了输入采样Sampler。Hadoop自带的采样方法如下图所示：
InputSampler类实现了三种采样方法：RandomSampler、SplitSampler 和 IntervalSampler。它们都是InputSampler的静态内部类，都实现了InputSampler的内部接口Sampler，接口的方法如下：
public interface Sampler<K,V>{
K[] getSample (InputFormat<K,V> inf ,JobConf job) throws IOException;
}
getSample
方法根据Job的配置信息以及输入格式获得抽样结果，三个采样类各自有不同的实现。
InputSampler 里面的 writePartitionFile方法定义如下：
public static <K,V> void writePartitionFile(JobConf job,org.apache.hadoop.mapreduce.lib.partition.InputSampler.Sampler<K,V> sampler) throws IOException,ClassNotFoundException,InterruptedException
writePartitionFile方法是将采样的结果排序，然后按照分区的个数n，将排序后的结果平均分为n份，取n-1个分割点，这个分割点具体取得时候，运用一些4舍5入得方法，可以理解是取后n-1个组中每组的第一个采样值。