MR实现--矩阵乘法

import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.io.*;
import org.apache.hadoop.mapreduce.Job;
import org.apache.hadoop.mapreduce.Mapper;
import org.apache.hadoop.mapreduce.Reducer;
import org.apache.hadoop.mapreduce.lib.input.FileInputFormat;
import org.apache.hadoop.mapreduce.lib.input.FileSplit;
import org.apache.hadoop.mapreduce.lib.output.FileOutputFormat;
import org.apache.hadoop.fs.Path;
public class matrix {
    public static int rowM=0;
    public static int columnM=0;
    public static int columnN=0;
    public static class MyMapper extends Mapper<Object, Text, Text, Text>{
        private Text map_key=new Text();
        private Text map_value=new Text();        
        public void setup(Context context){
            Configuration conf=context.getConfiguration();
            columnN=Integer.parseInt(conf.get("columnN"));
            rowM=Integer.parseInt(conf.get("rowM"));
        }
        public void map(Object key,Text value,Context context) throws IOException, InterruptedException{
            FileSplit fileSplit=(FileSplit)context.getInputSplit();
            String filename=fileSplit.getPath().getName();            
            System.out.println("map的数据分片长度是："+fileSplit.getLength());
            System.out.println("数据分片的起始位置是："+fileSplit.getStart());
            String[] tempLocation=fileSplit.getLocations();
            for (String string : tempLocation) {
                System.out.println("数据分片所在的主机是："+string);
            }
            if(filename.contains("M")){            
            String[] tuple=value.toString().split(",");
            int i=Integer.parseInt(tuple[0]);
            String[] tupleS=tuple[1].split("\t");
            int j=Integer.parseInt(tupleS[0]);
            int Mij=Integer.parseInt(tupleS[1]);
            for (int k = 1; k <columnN+1 ; k++) {
                map_key.set(i+","+k);
                map_value.set("M"+","+j+","+Mij);
                context.write(map_key, map_value);                
            }
            }
            else if(filename.contains("N")){            
                String[] tuple=value.toString().split(",");
                int j=Integer.parseInt(tuple[0]);
                String[] tupleS=tuple[1].split("\t");
                int k=Integer.parseInt(tupleS[0]);
                int Njk=Integer.parseInt(tupleS[1]);
                for (int i = 1; i <rowM+1 ; i++) {
                    map_key.set(i+","+k);
                    map_value.set("N"+","+j+","+Njk);
                    context.write(map_key, map_value);                
                }                
            }
        }
    }
    public static class MyReducer extends Reducer<Text, Text, Text, Text>{
        private int sum=0;
        public void setup(Context context) throws IOException{
            Configuration conf=context.getConfiguration();
            columnM=Integer.parseInt(conf.get("columnM"));    
        }
    public void reduce(Text key,Iterable<Text> value,Context context)throws IOException,InterruptedException{
        int[] M=new int[columnM+1];
        int[] N=new int[columnM+1];
        System.out.println(key.toString()+"对应的value列表所有值是：");
        for (Text val : value){
            System.out.println(val.toString());
            String[] tuple=val.toString().split(",");
            if(tuple[0].equals("M")){
                M[Integer.parseInt(tuple[1])]=Integer.parseInt(tuple[2]);                
            }else {
                N[Integer.parseInt(tuple[1])]=Integer.parseInt(tuple[2]);        
            }
        }
        for (int j=1;j<columnM+1;++j) {
            sum+=M[j]*N[j];
        }
        context.write(key, new Text(Integer.toString(sum)));
        sum=0;        
    }        
    }
    public static void main(String[] args)throws Exception {
        if(args.length!=3){
            System.err.println("Usage: MatrixMultiply <inputPathM> <inputPathN> <outputPath>");
        System.exit(2);
        }
        else{
            System.out.println("M文件路径:"+args[0]);
            String[] infoTupleM=args[0].split("_");
            rowM=Integer.parseInt(infoTupleM[1]);
            columnM=Integer.parseInt(infoTupleM[2]);
            String[] infoTupleN=args[1].split("_");
            columnN=Integer.parseInt(infoTupleN[2]);                
        }
        Configuration conf=new Configuration();
        conf.set("columnM", Integer.toString(columnM));
        conf.set("rowM", Integer.toString(rowM));
        conf.set("columnN", Integer.toString(columnN));
        Job job=new Job(conf, "Matrix");
        job.setJarByClass(matrix.class);
        job.setMapperClass(MyMapper.class);
        job.setReducerClass(MyReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);
        FileInputFormat.setInputPaths(job, new Path(args[0]),new Path(args[1]));
        FileOutputFormat.setOutputPath(job, new Path(args[2]));
        System.exit(job.waitForCompletion(true)?0:1);        
    }
}

     以上是j计算矩阵M*N结果的源码，总共需要三个输入参数，分别是：M矩阵的路径、N矩阵的路径以及结果的输入路径。其中M存放在文件中，文件的格式是"M_rows_columns"，实验的矩阵文件是M_300_500。实验中N的文件是N_500_700。并且M和N文件中的格式都是相同的，都是"i,j\tMij"的形式，其中i表示元素所在矩阵的行数，j表示元素所在矩阵的列数，Mij表示矩阵元素。如下图所示(N_500_700中形式也是如此)：

矩阵内都是随机数，矩阵文件由以下shell脚本生成：

#!/bin/bash
for i in `seq 1 $1`
do
    for j in `seq 1 $2`
    do 
        s=$(($RANDOM%100))
            echo -e "$i,$j\t$s" >>M_$1_$2
    done
done

2）map的输出形式：

假设M是i*j的矩阵，N是j*k的矩阵。

对于M矩阵：map的输出形式是(<i,k>,<"M",j,Mij>)，其中<i,k>是key，<"M",j,Mij>是value。

M表示此键值对是M矩阵的内容

Mij是M矩阵中的一个元素

i和j是这个元素在矩阵中的位置

k是矩阵N的列数

对于N矩阵：map的输出形式是(<i,k>,<"N",j,Njk>)，其中<i,k>是key，<"N",j,Njk>是value。

可以看到M和N经过map处理之后输出形式类似，key完全一样，其实key就表示结果矩阵中的第i行第k列，而reduce就是将<"M",j,Mij>和<"N",j,Njk>对应的元素相乘。

3）而map的输入形式是“1,1　　87 ”（也就是i，j，Mij），而map的输出形式是(<i,k>,<"M",j,Mij>),只有k是未知的，其实k就是N的列数，也是结果矩阵的列数，

从M中读取的数据就只有i，j，Mij，k就是N的列数，所以：

    if(filename.contains("M")){            
            String[] tuple=value.toString().split(",");
            int i=Integer.parseInt(tuple[0]);
            String[] tupleS=tuple[1].split("\t");
            int j=Integer.parseInt(tupleS[0]);
            int Mij=Integer.parseInt(tupleS[1]);
            for (int k = 1; k <columnN+1 ; k++) {
                map_key.set(i+","+k);
                map_value.set("M"+","+j+","+Mij);
                context.write(map_key, map_value);                
            }
            }

从N矩阵中读取到j，k，Njk，所以i就是M的行数，对于N是：

else if(filename.contains("N")){            
                String[] tuple=value.toString().split(",");
                int j=Integer.parseInt(tuple[0]);
                String[] tupleS=tuple[1].split("\t");
                int k=Integer.parseInt(tupleS[0]);
                int Njk=Integer.parseInt(tupleS[1]);
                for (int i = 1; i <rowM+1 ; i++) {
                    map_key.set(i+","+k);
                    map_value.set("N"+","+j+","+Njk);
                    context.write(map_key, map_value);                
                }                
            }

4）作业的配置，有个地方需要注意，就是设置了每个Map和Reduce节点都可以共享的三个变量：

    conf.set("columnM", Integer.toString(columnM));
    conf.set("rowM", Integer.toString(rowM));
    conf.set("columnN", Integer.toString(columnN));

5）为了获得columnN和rowM，重载了Mapper的setup函数：

public void setup(Context context){
            Configuration conf=context.getConfiguration();
            columnN=Integer.parseInt(conf.get("columnN"));
            rowM=Integer.parseInt(conf.get("rowM"));
        }

通过conf的get函数获得。同样的，为获得columnM，也重载了Reducer的setup函数。

    public void setup(Context context) throws IOException{
            Configuration conf=context.getConfiguration();
            columnM=Integer.parseInt(conf.get("columnM"));    
        }

 6）由于定义的reduce数量是5，所以最终生成了5个结果文件。