Hadoop疑难杂问

联邦机制

  虽然HDFS HA解决了“单点故障”问题，但是在系统扩展性、整体性能和隔离性方面仍然存在问题：
（1）系统扩展性方面，元数据存储在NN内存中，受内存上限的制约。
（2）整体性能方面，吞吐量受单个NN的影响。
（3）隔离性方面，一个程序可能会影响其他运行的程序，如一个程序消耗过多资源导致其他程序无法顺利运行。
  HDFS HA本质上还是单名称节点。HDFS联邦可以解决以上三个方面问题。
  在HDFS联邦中，设计了多个相互独立的NN，使得HDFS的命名服务能够水平扩展，这些NN分别进行各自命名空间和块的管理，不需要彼此协调。每个DN要向集群中所有的NN注册，并周期性的发送心跳信息和块信息，报告自己的状态。
  HDFS联邦拥有多个独立的命名空间，其中，每一个命名空间管理属于自己的一组块，这些属于同一个命名空间的块组成一个“块池”。每个DN会为多个块池提供块的存储，块池中的各个块实际上是存储在不同DN中的。

Hadoop租约机制

  HDFS文件是write-once-read-many，并且不支持客户端的并行写操作，这就需要一种机制来保证对HDFS文件的互斥操作。租约（Lease）机制是Namenode给予租约持有者在规定时间内拥有写文件权限的合同。每个客户端用户持有一个租约。每个租约内部包含1个租约持有者的信息,还有此租约对应的文件id列表,表示当前租约持有者正在写这些文件id对应的文件。每个租约包含有一个最新的更新时间,最新更新时间将会决定此租约是否过期,过期的租约会导致租约持有者无法继续执行写数据到文件中,除非进行租约的更新。
  与租约关系密切的类是LeaseManager类，Lease类，Monitor类以及客户端的LeaseRenewer类，其中Lease类和Monitor类是LeaseManager类的内部类。
  LeaseManager是Namenode中维护所有租约操作的类，它主要有三大功能：保存HDFS中所有租约的信息；提供租约的增删改查方法；维护一个Monitor线程定期对超过硬限制时间的文件进行租约恢复。
  Lease类即是租约类，它内部有3个字段和一些供LeaseManager管理租约时调用的方法。holder字段代表客户端租约持有者，files字段保存了该租约内的所有文件Id，lastUpdate字段保存了租约的最后更新时间。
  Monitor是一个Runnable类，其内部就实现了一个run()方法，调用LeaseManager.checkLeases()方法实现业务逻辑，它的作用是定期对超过硬限制时间的文件进行租约恢复操作。
  客户端可以通过LeaseRenewer更新自己的租约。其中有个线程定期检测租约的软限制时间，并调用LeaseRenewer.run()方法对租约过半的lease进行续约。

租约恢复
  租约恢复就是将处于构建状态的文件进行租约释放并关闭。以下四种情况会进行租约恢复操作：
（1）Monitor线程
（2）客户端调用recoverLease()方法
（3）appendFile
（4）startFile

  第一种情况直接调用internalReleaseLease()方法实现租约恢复，其中参数newHolder为”HDFS_NameNode-时间”；后面三种情况调用recoverLeaseInternal()方法，在recoverLeaseInternal()方法内部调用internalReleaseLease()方法实现租约恢复，第二种情况的参数force为true，newHolder为当前客户端，第三四种情况的参数force为false，newHolder为null。

MapReduce为什么需要排序

  MapReduce中需要对数据进行分组，排序的目的是为了对key进行分组，可以说是一种实现方式。如果需要算法或计算逻辑中不需要任何的有序性，那么可以去采用其他更快的分组实现方式，如Hash实现对key的分组。虽然也有并不关心数据是否局部有序的应用场景，但在数据访问和计算中，保证数据有序性是一个必要功能。在通过sort实现数据分组的同时保证了分组内数据有序性，也算是一举两得，并且这样在要求数据有序性的场景中，对局部有序的数据再进行全局排序将会有不少帮助。

Hadoop运行模式

（1）本地模式（默认模式）：不需要启用单独进程，直接可以运行，测试和开发时使用
（2）伪分布式模式：等同于完全分布式，只有一个节点
（3）完全分布式模式：多个节点一起运行

伪分布式运行Hadoop 案例

  伪分布式模式是在一台单机上运行，但用不同的Java进程模仿分布式运行中的各类结点(NameNode,DataNode,ResourceManager,SecondaryNameNode)

    2.1 启动HDFS并运行MapReduce 程序
		1）执行步骤
			（1）配置集群
				（a）配置：hadoop-env.sh
					Linux系统中获取jdk的安装路径：
					修改JAVA_HOME 路径：
				（b）配置：core-site.xml
				（c）配置：hdfs-site.xml  
			（2）启动集群
				（a）格式化namenode（第一次启动时格式化，以后就不要总格式化）
				（b）启动namenode
				（c）启动datanode
			（3）查看集群
				（a）查看是否启动成功
				（b）查看产生的log日志
				（c）web端查看HDFS文件系统
			（4）操作集群
				（a）在hdfs文件系统上创建一个input文件夹
				（b）将测试文件内容上传到文件系统上
				（c）查看上传的文件是否正确
				（d）运行mapreduce程序
				（e）查看输出结果
					命令行查看：
					浏览器查看
						浏览器查看.png
				（f）将测试文件内容下载到本地
				（g）删除输出结果

	 2.2 YARN上运行MapReduce 程序
		1）执行步骤
			（1）配置集群
				（a）配置yarn-env.sh
					配置一下JAVA_HOME
				（b）配置yarn-site.xml
				（c）配置：mapred-env.sh
					配置一下JAVA_HOME
				（d）配置： (对mapred-site.xml.template重新命名为) mapred-site.xml
			（2）启动集群
				（a）启动前必须保证namenode和datanode已经启动
				（b）启动resourcemanager
				（c）启动nodemanager
			（3）集群操作
				（a）yarn的浏览器页面查看
					http://192.168.1.101:8088/cluster
				（b）删除文件系统上的output文件
				（c）执行mapreduce程序
				（d）查看运行结果

完全分布式

集群部署规划

–	hadoop1	hadoop2	hadoop3
HDFS	NameNode、DataNode	DataNode	SecondaryNameNode、DataNode
YARN	NodeManager	ResourceManager、NodeManager	NodeManager

配置文件
core-site.xml

<!-- 指定 HDFS 中 NameNode 的地址 -->
	<property>
		<name>fs.defaultFS</name>
		<value>hdfs://hadoop132:9000</value>
	</property>
<!-- 指定 hadoop 运行时产生文件的存储目录 -->
	<property>
		<name>hadoop.tmp.dir</name>
		<value>/opt/module/hadoop-2.7.2/data/tmp</value>
	</property>

hadoop-env.sh

export JAVA_HOME=/opt/module/jdk1.8.0_144

hdfs-site.xml

<configuration> 
	<property>
		<name>dfs.replication</name>
		<value>3</value>
	</property>
	<property>
		<name>dfs.namenode.secondary.http-address</name>
		<value>hadoop134:50090</value>
	</property>
</configuration>

slaves

hadoop132
hadoop133
hadoop134

yarn
yarn-env.sh

export JAVA_HOME=/opt/module/jdk1.8.0_144

yarn-site.xml

<configuration>
<!-- reducer 获取数据的方式 -->
	<property>
		<name>yarn.nodemanager.aux-services</name>
		<value>mapreduce_shuffle</value>
	</property>
<!-- 指定 YARN 的 ResourceManager 的地址 -->
	<property>
		<name>yarn.resourcemanager.hostname</name>
		<value>hadoop133</value>
	</property>
</configuration>

mapreduce
mapred-env.sh

export JAVA_HOME=/opt/module/jdk1.8.0_144

mapred-site.xml

<configuration>
	<!-- 指定 mr 运行在 yarn 上 -->
	<property>
		<name>mapreduce.framework.name</name>
		<value>yarn</value>
	</property>
</configuration>

集群同步以上配置文件
启动集群

如果集群是第一次启动，需要格式化 namenode
$ bin/hdfs namenode -format
$ sbin/start-dfs.sh

第二台机器上启动yarn
$ sbin/start-yarn.sh

Hadoop搭建过程为什么修改IP
让节点机器的ip固定下来，让Hadoop能找到机器，需要进行静态ip配置。

Hadoop搭建过程SSH免密登录有什么作用
在集群中，Hadoop控制脚本依赖SSH来执行针对整个集群的操作。所以，需要安装SSH，但是，SSH远程登陆的时候，需要密码验证，集群中数千台计算机，数千台计算机都需要手工输入密码，这是不太现实的，所以，就需要配置SSH无密码登录。

（0）这里有A、B两台服务器，首先让A生成两个密钥，一个公钥，一个私钥
（1）A携带主机名和用户以及公钥访问公钥B
（2）B接收到A的请求后，把A的公钥去授权列表authorized_keys中核查看看有没有A的公钥，如果没有把A的公钥放进去，然后用A的公钥加密一个随机字符串返回给A
（3）这时A拿到该加密字符串解密成功后携带A的私钥返回给B，这时候B通过去授权列表验证，验证通过返回到A
（4）A就可以免密登录成功

实现免密登录
  ssh-genkey是生成密钥的工具，执行完成后生成公钥和密钥，这两个文件会默认保存在~ /.ssh/路径下。直接执行来生成密钥，所有的参数都可以为空，即一直回车确认。此时，生成的文件在~/.ssh/目录下，我们会看到这些文件：

id_rsa    // 私钥文件  
id_rsa.pub    // 公钥文件
authorized_keys    // 存放客户端公钥的文件
known_hosts    // 确认过公钥指纹的可信服务器列表的文件
config    // 指定不同域名使用哪个密钥的配置文件

  因为一台机器即能是客户端，又能是服务端，因此同时存在authorized_keys（在该机器为服务端时使用）和Known_hosts（在该机器为客户端时使用）。
  我们的服务器会有很多的用户，如果所有的用户都用同一份密钥，可能就没办法划分权限或者区分用户，如多个用户提交git就需要按照用户名来生成密钥，用于区分用户。同时你可能也希望针对不同的服务器使用不同的密钥对，因此需要config配置文件来配置针对不同服务器的配置，这样在连接不同的服务器时，就会使用不同的密钥文件来登录。
  在客户端生成密钥对之后，将公钥追加到服务器的authorized_keys文件中即可。此时，即可免密登录服务器。

Hadoop搭建过程为什么关闭防火墙
  因为都是内网搭建的，对外还有一个服务器的，那个服务器有防火墙，由它来访问内网集群，如果内网内开启防火墙，内网集群通讯会出现很多问题。

正常的Hadoop集群会启动哪些进程

1. NameNode它是Hadoop中的主服务器，管理文件系统名称空间和对集群中存储的文件的访问，保存有metadate
2. SecondaryNameNode它不是NameNode的冗余守护进程，而是提供周期检查点和清理任务。帮助NameNode合并editslog，减少NameNode启动时间
3. DataNode它负责管理连接到节点的存储（一个集群中可以有多个节点）。每个存储数据的节点运行一个DataNode守护进程
4. ResourceManager
5. NodeManager
6. DFSZKFailoverController高可用时它负责监控NameNode的状态，并及时的把状态信息写入ZooKeeper。它通过一个独立线程周期性的调用NameNode上的一个特定接口来获取NameNode的健康状态
7. JournalNode 高可用情况下存放NameNode的editlog文件

用MapReduce实现top10

public class TopNWritable implements WritableComparable<TopNWritable> {
    private String word;
    private int value;
    public TopNWritable(String word, int value) {
        this.word = word;
        this.value = value;
    }
    public int compareTo(TopNWritable o) {
        int tmp =  o.value - this.value;   //降序
        if(tmp != 0){
            return tmp;
        }
        return this.word.compareTo(o.word);
    }
}
public class TopN {
    //自定义的mapper类
    public static class MyMapper extends Mapper<Object, Text, Text, LongWritable> {
        Text k = new Text();
        @Override
        protected void map(Object key, Text value,Context context) throws IOException, InterruptedException {
            String row = value.toString();
            String [] words = row.split(" ");
            for (String s : words) {
                k.set(s);
                context.write(k, new LongWritable(1L));
            }
        }
    }
    //自定义reducer类
    public static class MyReducer extends Reducer<Text, LongWritable, Text, IntWritable> {
        IntWritable v = new IntWritable();
        final static int N = 3;
        TreeSet<TopNWritable> ts = new TreeSet<TopNWritable>();
        @Override
        protected void reduce(Text key, Iterable<LongWritable> value,Context context) throws IOException, InterruptedException {
            int counter = 0;
            for (LongWritable i : value) {
                counter += i.get();
            }
            v.set(counter);
            TopNWritable tw = new TopNWritable(key.toString(),counter);
            ts.add(tw);
            if(ts.size() > N){
                ts.remove(ts.last());
            }
        }
        @Override
        protected void cleanup(Context context) throws IOException, InterruptedException {
            for (TopNWritable tn : ts){
                context.write(new Text(tn.getWord()), new IntWritable(tn.getValue()));
            }
        }
    }
    public static void main(String[] args) {
        try {
            Configuration conf = new Configuration();
            Job job = Job.getInstance(conf, "topN");
            job.setJarByClass(TopN.class);
            job.setMapperClass(MyMapper.class);
            job.setMapOutputKeyClass(Text.class);
            job.setMapOutputValueClass(LongWritable.class);
            job.setReducerClass(MyReducer.class);
            job.setOutputKeyClass(Text.class);
            job.setOutputValueClass(IntWritable.class);
            FileInputFormat.addInputPath(job, new Path(args[0]));
            FileOutputFormat.setOutputPath(job, new Path(args[1]));
            int success = job.waitForCompletion(true) ? 0 : 1;
            System.exit(success);
        } catch (IOException | ClassNotFoundException | InterruptedException e) {
            e.printStackTrace();
        }
    }
}

MapReduce实现矩阵乘法

  Cij其实就是A矩阵的第i行和B矩阵的第j列的点积，所以只要能最终将参与计算Cij的所有元素（A矩阵的第i行和B矩阵的第j列）都归到一组来参与计算就能算出Cij。这个所谓的“归到一组”，结合MR模型和矩阵乘法规则，其实就是Map将这些元素输出为相同的Key—C矩阵中元素的坐标，然后通过Shuffle就能把所有相同Key的元素输入到Reduce中，由Reduce来进行点积运算，得出该C元素最终的值。
  回到输入数据，即A和B两个矩阵，只需要将矩阵中的每个元素处理一下（该过程需要在Map中进行），根据每一个元素即将参与哪些Cij的计算，为每一个元素打上（i，j）坐标即可，这样最终这些元素就会被shuffle到目标Cij的计算数据源分组中。
  具体举例，A12会参与到C11，C12的计算中；B22会参与到C12，C22的计算中。所以，从A和B的元素坐标，就完全可以得知它们即将参与计算的C元素的坐标。通过以上的分析，对于一个i行j列的A矩阵，和j行k列的B矩阵乘法：

    我们将每个Aij元素处理为如下格式：
    key=i,n(n=1,2,3...k)      value='a',j,aij
    我们将每个Bjk处理为如下格式：
    key= m,k(m=1,2,3...i)     value='b',i,bij

A12最终会参与C11，C12的计算，所以我们处理A12时需将其处理为两个{key，value}对：{（1,1），（‘a’ , 2 , 2）} /* (1,1)是A12将参与计算的C11的坐标；'a’代表该数据来自A矩阵，因为A和B需要相乘，所以需要做一个标志位；头一个2代表这是计算C11时对应A向量的坐标，因为要知道A向量的第几个元素和B向量的第几个元素相乘；最后一个2就是当前元素的值 * /。 {（1,2），（‘a’ , 2 , 2）}/ * 参考以上描述 * /

import java.io.IOException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.conf.Configured;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.IntWritable;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.mapreduce.InputSplit;
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.util.Tool;
import org.apache.hadoop.util.ToolRunner;

public class MapReduceDemo extends Configured implements Tool{
    static class DemoMapper extends Mapper<LongWritable,Text,Text,Text>{
        private String filename;
        private int rownum=2;
        private int colnum=2;
        private int rowA=1;
        private int rowB=1;
        protected void setup(Context context)throws IOException,InterruptedException{
            InputSplit split=context.getInputSplit();
            filename=((FileSplit)split).getPath().getName();
        }
        protected void map(LongWritable key,Text value,Context context)throws IOException,InterruptedException{
            String[] token=value.toString().split(",");
            if(filename.equals("A")){
                for(int i=1;i<=colnum;++i){
                       Text k=new Text(rowA+","+i);
                       for(int j=1;j<=token.length;++j){
                           Text v=new Text(filename+":"+j+","+token[j-1]);
                           context.write(k, v);
                           System.out.println(k.toString()+" "+v.toString());
                       }
                }
                ++rowA;
            }
            else if(filename.equals("B")){
                for(int i=1;i<=rownum;++i){
                    for(int j=1;j<=token.length;++j){
                        Text k=new Text(i+","+j);
                        Text v=new Text(filename+":"+rowB+","+token[j-1]);
                        context.write(k, v);
                        System.out.println(k.toString()+" "+v.toString());
                    }
                }
                ++rowB;
            }            
        }
    }
    static class DemoReducer extends Reducer<Text,Text,Text,IntWritable>{
        private Map<String,String> mapA=new HashMap<String,String>();
        private Map<String,String> mapB=new HashMap<String,String>();
        protected void reduce(Text key,Iterable<Text> values,Context context)throws IOException,InterruptedException{
            for(Text line:values){
                String filename=line.toString().substring(0,1);
                if(filename.equals("A")){
                    mapA.put(line.toString().substring(2,3), line.toString().substring(4));
                }else if(filename.equals("B")){
                    mapB.put(line.toString().substring(2, 3),line.toString().substring(4));
                }
            }
            int result=0;
            Iterator<String> it=mapA.keySet().iterator();
            while(it.hasNext()){
                String mapk=it.next();
                result+=Integer.parseInt(mapA.get(mapk))*Integer.parseInt(mapB.get(mapk));
            }
            context.write(key, new IntWritable(result));
            System.out.println();
        }
    }
    public static void main(String[] args) throws Exception {
        int exitcode=ToolRunner.run(new MapReduceDemo(), args);
        System.exit(exitcode);
    }
    @Override
    public int run(String[] arg0) throws Exception {
        Configuration conf=new Configuration();
        Job job=new Job(conf);
        job.setJarByClass(getClass());
        FileInputFormat.setInputPaths(job, new Path(arg0[0]),new Path(arg0[1]));
        FileOutputFormat.setOutputPath(job, new Path(arg0[2]));
        job.setMapperClass(DemoMapper.class);
        job.setReducerClass(DemoReducer.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);
        return job.waitForCompletion(true)? 1:0;
    }
}

MR求共同好友

以下是qq的好友列表数据，冒号前是一个用户，冒号后是该用户的所有好友（数据中的好友关系是单向的）
A:B,C,D,F,E,O
B:A,C,E,K
C:F,A,D,I
D:A,E,F,L
E:B,C,D,M,L
F:A,B,C,D,E,O,M
G:A,C,D,E,F
H:A,C,D,E,O
I:A,O
J:B,O
K:A,C,D
L:D,E,F
M:E,F,G
O:A,H,I,J
https://www.cnblogs.com/songhaowan/p/7239578.html
求出哪些人两两之间有共同好友，及他俩的共同好友都有谁？
解题思路：
第一步
map
读一行 A:B,C,D,F,E,O
输出

import java.io.IOException;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
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.output.FileOutputFormat;
public class SharedFriendsStepOne {
    static class SharedFriendsStepOneMapper extends   Mapper<LongWritable, Text, Text, Text>{
        @Override
        protected void map(LongWritable key, Text value, Mapper<LongWritable, Text, Text, Text>.Context context)
                throws IOException, InterruptedException {
             //A:B,C,D,F,E,O
            // B:A,C,E,K
            String line = value.toString();
            //每个用户的粉丝列表
            String[] person_friends = line.split(":");
            String user = person_friends[0];
            String friends = person_friends[1];
            for (String friend : friends.split(",")) {
                //map输出用户的粉丝<粉丝，用户>给reduce
                context.write(new Text(friend), new Text(user));
            }
        }
    }
    static class SharedFriendsStepOneReducer extends Reducer<Text, Text, Text, Text> {
        @Override
        protected void reduce(Text friend, Iterable<Text> persons, Context context) throws IOException, InterruptedException {
            StringBuffer sb = new StringBuffer();
            for (Text person : persons) {
                sb.append(person).append(",");
            }
            context.write(friend, new Text(sb.toString()));
        }
    }
    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf);
        job.setJarByClass(SharedFriendsStepOne.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);
        job.setMapperClass(SharedFriendsStepOneMapper.class);
        job.setReducerClass(SharedFriendsStepOneReducer.class);
        FileInputFormat.setInputPaths(job, new Path("srcdata/friends"));
        FileOutputFormat.setOutputPath(job, new Path("temp/out"));
        job.waitForCompletion(true);
    }
}

第二步：找出 <人-人，好友> ，这样，相同的“人-人”对的所有好友就会到同1个reduce中去

import java.io.IOException;
import java.util.Arrays;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.fs.Path;
import org.apache.hadoop.io.LongWritable;
import org.apache.hadoop.io.Text;
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.output.FileOutputFormat;
public class SharedFriendsStepTwo {
    static class SharedFriendsStepTwoMapper extends Mapper<LongWritable, Text, Text, Text> {
        // 拿到的数据是上一个步骤的输出结果
        // A I,K,C,B,G,F,H,O,D,
        // 友 人，人，人
        @Override
        protected void map(LongWritable key, Text value, Context context) throws IOException, InterruptedException {
            String line = value.toString();
            String[] friend_persons = line.split("\t");
            String friend = friend_persons[0];
            String[] persons = friend_persons[1].split(",");
            //对用户排序
            Arrays.sort(persons);
            for (int i = 0; i < persons.length - 1; i++) {
                for (int j = i + 1; j < persons.length; j++) {
                    // 发出 <人-人，好友> ，这样，相同的“人-人”对的所有好友就会到同1个reduce中去
                    context.write(new Text(persons[i] + "-" + persons[j]), new Text(friend));
                }
            }
        }
    }
    static class SharedFriendsStepTwoReducer extends Reducer<Text, Text, Text, Text> {
        @Override
        protected void reduce(Text person_person, Iterable<Text> friends, Context context) throws IOException, InterruptedException {
            StringBuffer sb = new StringBuffer();
            for (Text friend : friends) {
                sb.append(friend).append(" ");
            }
            context.write(person_person, new Text(sb.toString()));
        }
    }
    public static void main(String[] args) throws Exception {
        Configuration conf = new Configuration();
        Job job = Job.getInstance(conf);
        job.setJarByClass(SharedFriendsStepTwo.class);
        job.setOutputKeyClass(Text.class);
        job.setOutputValueClass(Text.class);
        job.setMapperClass(SharedFriendsStepTwoMapper.class);
        job.setReducerClass(SharedFriendsStepTwoReducer.class);
        FileInputFormat.setInputPaths(job, new Path("/temp/out/part-r-00000"));
        FileOutputFormat.setOutputPath(job, new Path("/temp/out2"));
        job.waitForCompletion(true);
    }
}

MapReduce求二度好友

https://blog.csdn.net/u013926113/article/details/51539306