第七章：小朱笔记hadoop之源码分析-hdfs分析 第四节：namenode分析-namenode启动过程分析

第七章：小朱笔记hadoop之源码分析-hdfs分析

第四节：namenode分析

4.1 namenode启动过程分析

       org.apache.hadoop.hdfs.server.namenode.main 方法是系统的入口,它会调用 createNameNode 创建 NameNode 实例。 createNameNode 分析命令行参数,如果是 FORMAT 戒 FINALIZE,调用对应的方法后退出,如果是其他的参数,将创建NameNode 对象。NameNode的构造函数会调initialize,初始化NameNode的成员发量,包括创建 RPC 服务器,初始化FSNamesystem,初始化RPC服务器和回收站线程。
   创建的服务如下：

  

服务                             类                            
server                   ipc.RPC.Server       
serviceRpcServer         ipc.RPC.Server  
HttpServer               http.HttpServer  
Trash Emptier            fs.Trash.Trash.Emptier  
hbthread                 hdfs.server.namenode.FSNamesystem.HeartbeatMonitor    
lmthread                 hdfs.server.namenode.LeaseManager.Monitor  
replthread               hdfs.server.namenode.FSNamesystem.ReplicationMonitor  
dnthread                 hdfs.server.namenode.DecommissionManager.Monitor

 初始化 name-node 入口：

 /** 
 * Initialize name-node. 
 *  
 * @param conf the configuration 
 */  
private void initialize(Configuration conf) throws IOException {  
  InetSocketAddress socAddr = NameNode.getAddress(conf);  
  //从配置conf中获取到Namenode服务器所使用的Socket地址 读取fs.default.name的值，获取hdfs集群的地址    
    
  UserGroupInformation.setConfiguration(conf);  
  //设置用户权限信息  
     
  //如果dfs.namenode.keytab.file存在，并且kerberos已经开启，则调用UserGroupInformation.loginUserFromKeytab进行登陆    
  //登陆使用dfs.namenode.kerberos.principal作为用户名，否则使用当前linux的user作为用户。    
  SecurityUtil.login(conf, DFSConfigKeys.DFS_NAMENODE_KEYTAB_FILE_KEY,   
      DFSConfigKeys.DFS_NAMENODE_USER_NAME_KEY, socAddr.getHostName());  
    
  //获取namenode同时处理请求的数量配置，默认为10   服务器上处理器Handler线程的数量    
  int handlerCount = conf.getInt("dfs.namenode.handler.count", 10);  
    
  // set service-level authorization security policy  
  //如果授权配置(hadoop.security.authorization)开启了，则刷新授权策略    
  if (serviceAuthEnabled = conf.getBoolean(ServiceAuthorizationManager.SERVICE_AUTHORIZATION_CONFIG, false)) {  
    //默认会重新加载hadoop-policy.xml中的acl配置，加载完成后acl配置保存在  
    ServiceAuthorizationManager.refresh(conf, new HDFSPolicyProvider());  
  }  
    
  //创建服务指标，用于观察namenode服务状态    
  myMetrics = NameNodeInstrumentation.create(conf);// 初始化NameNodeMetrics   
    
  //启动FSNamesystem,启动FSNamesystem时，会启动各种thread执行namenode职责    
  //1.init FSNamesystem  
  this.namesystem = new FSNamesystem(this, conf);  
  
  //如果安全机制开启    
  if (UserGroupInformation.isSecurityEnabled()) {    
    //启动守护线程每5秒执行一次ExpiredTokenRemover    
    namesystem.activateSecretManager();    
  }    
  
  //2.init namenode-datanode,namenode-snn RPC Server  
  //创建rpc服务器，如果dfs.namenode.servicerpc-address配置项存在，则用来作为服务器地址  
  InetSocketAddress dnSocketAddr = getServiceRpcServerAddress(conf);  
  if (dnSocketAddr != null) {  
    int serviceHandlerCount =  
      conf.getInt(DFSConfigKeys.DFS_NAMENODE_SERVICE_HANDLER_COUNT_KEY,  
                  DFSConfigKeys.DFS_NAMENODE_SERVICE_HANDLER_COUNT_DEFAULT);  
    this.serviceRpcServer = RPC.getServer(this, dnSocketAddr.getHostName(),   
        dnSocketAddr.getPort(), serviceHandlerCount,  
        false, conf, namesystem.getDelegationTokenSecretManager());  
    this.serviceRPCAddress = this.serviceRpcServer.getListenerAddress();  
    setRpcServiceServerAddress(conf);  
  }  
    
  //3.init namenode-client RPC Server  
  this.server = RPC.getServer(this, socAddr.getHostName(),socAddr.getPort(), handlerCount, false, conf, namesystem.getDelegationTokenSecretManager());  
  
  // The rpc-server port can be ephemeral... ensure we have the correct info  
  this.serverAddress = this.server.getListenerAddress();   
    
  FileSystem.setDefaultUri(conf, getUri(serverAddress));  
  LOG.info("Namenode up at: " + this.serverAddress);  
  
    
  //4. start Http Server  
  startHttpServer(conf);  
    
  //5. start namenode-client RPC Server  
  this.server.start();     
    
  if (serviceRpcServer != null) {  
    serviceRpcServer.start();     
    //6. start namenode-datanode,namenode-snn RPC Server  
  
  }  
    
  //7.start TrashEmptier  
  //启动垃圾清理守护线程，读取fs.trash.interval的值作为两次清理的时间间隔。默认每60分钟清理一次    
  startTrashEmptier(conf);  
}  

 

（1）初始化FSNamesystem

启动FSNamesystem,启动FSNamesystem时，会启动各种thread执行namenode职责。FSNamesystem 的构造函数会调用 initialize 方法,去初始化上面我们分析过的一堆成员发量。几个重要的步骤包括加载 FSImage editlog 设置系统为安全模式,初始化各个工作线程和 HTTP 服务器。

FSNamesystem重要属性：

 // Default initial capacity and load factor of map  
  public static final int DEFAULT_INITIAL_MAP_CAPACITY = 16;  
  public static final float DEFAULT_MAP_LOAD_FACTOR = 0.75f;  
    
  private boolean isPermissionEnabled;//是否打开权限检查，可以通过配置项dfs.permissions来设置。  
    
  //本地文件的用户文件属主和文件组，可以通过hadoop.job.ugi设置，如果没有设置，那么将使用启动HDFS的用户（通过whoami获得）和该用户所在的组（通过groups获得）作为值  
  private UserGroupInformation fsOwner;  
    
  private String supergroup;//对应配置项dfs.permissions.supergroup，应用在defaultPermission中，是系统的超级组。  
    
  //缺省权限，缺省用户为fsOwner，缺省用户组为supergroup，缺省权限为0777，可以通过dfs.upgrade.permission修改。  
  private PermissionStatus defaultPermission;  
  // FSNamesystemMetrics counter variables  
  //系统总容量/已使用容量/剩余容量  
  private long capacityTotal = 0L, capacityUsed = 0L, capacityRemaining = 0L;  
    
  //系统总连接数，根据DataNode心跳信息跟新  
  private int totalLoad = 0;  
  boolean isAccessTokenEnabled;  
  BlockTokenSecretManager accessTokenHandler;  
  private long accessKeyUpdateInterval;  
  private long accessTokenLifetime;  
    
  // Scan interval is not configurable.  
  private static final long DELEGATION_TOKEN_REMOVER_SCAN_INTERVAL =  
    TimeUnit.MILLISECONDS.convert(1, TimeUnit.HOURS);  
  private DelegationTokenSecretManager dtSecretManager;  
  
  //分别是成员变量pendingReplications（正在复制的数据块），  
  //neededReplications（需要复制的数据块）的大小，  
  //scheduledReplicationBlocksCount是当前正在处理的复制工作数目  
    
  volatile long pendingReplicationBlocksCount = 0L;  
  volatile long corruptReplicaBlocksCount = 0L;  
  volatile long underReplicatedBlocksCount = 0L;  
  volatile long scheduledReplicationBlocksCount = 0L;  
  volatile long excessBlocksCount = 0L;  
  volatile long pendingDeletionBlocksCount = 0L;  
  //  
  // Stores the correct file name hierarchy  
  //指向系统使用的FSDirectory对象。  
  public FSDirectory dir;  
  
  //  
  // Mapping: Block -> { INode, datanodes, self ref }   
  // Updated only in response to client-sent information.  
  //  
  final BlocksMap blocksMap = new BlocksMap(DEFAULT_INITIAL_MAP_CAPACITY,   
                                            DEFAULT_MAP_LOAD_FACTOR);  
  
  //  
  // Store blocks-->datanodedescriptor(s) map of corrupt replicas  
  //  
  //保存损坏（如：校验没通过）的数据块到对应DataNode的关系，CorruptReplicasMap类图如下，类只有一个成员变量，  
  //保存Block到一个DatanodeDescriptor的集合的映射和这个映射上的一系列操作  
  //  
  public CorruptReplicasMap corruptReplicas = new CorruptReplicasMap();  
      
  /** 
   * Stores the datanode -> block map.   
   * <p> 
   * Done by storing a set of {@link DatanodeDescriptor} objects, sorted by  
   * storage id. In order to keep the storage map consistent it tracks  
   * all storages ever registered with the namenode. 
   * A descriptor corresponding to a specific storage id can be 
   * <ul>  
   * <li>added to the map if it is a new storage id;</li> 
   * <li>updated with a new datanode started as a replacement for the old one  
   * with the same storage id; and </li> 
   * <li>removed if and only if an existing datanode is restarted to serve a 
   * different storage id.</li> 
   * </ul> <br> 
   * The list of the {@link DatanodeDescriptor}s in the map is checkpointed 
   * in the namespace image file. Only the {@link DatanodeInfo} part is  
   * persistent, the list of blocks is restored from the datanode block 
   * reports.  
   * <p> 
   * Mapping: StorageID -> DatanodeDescriptor 
   *  
   * 保存了StorageID >> DatanodeDescriptor的映射，用于保证DataNode使用的Storage的一致性。 
   */  
  NavigableMap<String, DatanodeDescriptor> datanodeMap =  new TreeMap<String, DatanodeDescriptor>();  
  
  //  
  // Keeps a Collection for every named machine containing  
  // blocks that have recently been invalidated and are thought to live  
  // on the machine in question.  
  // Mapping: StorageID -> ArrayList<Block>  
  //  
  // 保存了每个DataNode上无效但还存在的数据块（StorageID >> ArrayList<Block>）。  
    
  // 保存了每个DataNode上有效，但需要删除的数据块（StorageID >> TreeSet<Block>），这种情况可能发生在一个DataNode故障后恢复后，  
  // 上面的数据块在系统中副本数太多，需要删除一些数据块。  
  private Map<String, Collection<Block>> recentInvalidateSets =  new TreeMap<String, Collection<Block>>();  
  
  //  
  // Keeps a TreeSet for every named node.  Each treeset contains  
  // a list of the blocks that are "extra" at that location.  We'll  
  // eventually remove these extras.  
  // Mapping: StorageID -> TreeSet<Block>  
  //保存Datanode上有效但需要删除的数据块（StorageID -> TreeSet<Block>）比如一个Datanode故障恢复后，上面的数据块在系统中副本数太多，需要删除一些数据块。  
  //  
  Map<String, Collection<Block>> excessReplicateMap = new TreeMap<String, Collection<Block>>();  
  
  Random r = new Random();  
  
  /** 
   * Stores a set of DatanodeDescriptor objects. 
   * This is a subset of {@link #datanodeMap}, containing nodes that are  
   * considered alive. 
   * The {@link HeartbeatMonitor} periodically checks for outdated entries, 
   * and removes them from the list. 
   * 所有目前活着的DataNode，线程HeartbeatMonitor会定期检查 
   */  
  ArrayList<DatanodeDescriptor> heartbeats = new ArrayList<DatanodeDescriptor>();  
  
/** 
 * Store set of Blocks that need to be replicated 1 or more times. 
 * Set of: Block 
 *  
 * 需要进行复制的数据块。UnderReplicatedBlocks的类图如下，它其实是一个数组，数组的下标是优先级（0的优先级最高，如果数据块只有一个副本，它的优先级是0）， 
 * 数组的内容是一个Block集合。UnderReplicatedBlocks提供一些方法，对Block进行增加，修改，查找和删除。 
 *  
 */  
  private UnderReplicatedBlocks neededReplications = new UnderReplicatedBlocks();  
  // We also store pending replication-orders.保存正在复制的数据块的相关信息  
  private PendingReplicationBlocks pendingReplications;  
  
  public LeaseManager leaseManager = new LeaseManager(this);   
  
  //  
  // Threaded object that checks to see if we have been  
  // getting heartbeats from all clients.   
  //  
  Daemon hbthread = null;   // HeartbeatMonitor thread 对应DataNode心跳检查  
  public Daemon lmthread = null;   // LeaseMonitor thread 租约检查  
  Daemon smmthread = null;  // SafeModeMonitor thread 安全模式检查  
  public Daemon replthread = null;  // Replication thread 数据块复制  
  private ReplicationMonitor replmon = null; // Replication metrics  
    
  private volatile boolean fsRunning = true; //系统运行标志  
  long systemStart = 0;//系统启动时间  
  
  //  The maximum number of replicates we should allow for a single block  
  private int maxReplication;  
  //  How many outgoing replication streams a given node should have at one time  
  private int maxReplicationStreams;  
  // MIN_REPLICATION is how many copies we need in place or else we disallow the write  
  private int minReplication;  
  // Default replication  
  private int defaultReplication;  
  // Variable to stall new replication checks for testing purposes  
  private volatile boolean stallReplicationWork = false;  
  // heartbeatRecheckInterval is how often namenode checks for expired datanodes  
  private long heartbeatRecheckInterval;  
  // heartbeatExpireInterval is how long namenode waits for datanode to report  
  // heartbeat  
  private long heartbeatExpireInterval;  
  //replicationRecheckInterval is how often namenode checks for new replication work  
  private long replicationRecheckInterval;  
  // default block size of a file  
  private long defaultBlockSize = 0;  
  // allow appending to hdfs files  
  private boolean supportAppends = true;  
  
  /** 
   * Last block index used for replication work. 
   */  
  private int replIndex = 0; ///和neededReplications配合，记录下一个进行复制的数据块位置。  
  private long missingBlocksInCurIter = 0;  
  private long missingBlocksInPrevIter = 0;   
  
  public static FSNamesystem fsNamesystemObject;  
  /** NameNode RPC address */  
  private InetSocketAddress nameNodeAddress = null; // TODO: name-node has this field, it should be removed here  
    
  //安全模式是这样一种状态，系统处于这个状态时，不接受任何对名字空间的修改，同时也不会对数据块进行复制或删除数据块。  
  //NameNode启动的时候会自动进入安全模式，同时也可以手工进入（不会自动离开）。系统启动以后，DataNode会报告目前它拥有的数据块的信息，  
  //当系统接收到的Block信息到达一定门槛，同时每个Block都有dfs.replication.min个副本后，系统等待一段时间后就离开安全模式。这个门槛定义的参数包括：  
  //dfs.safemode.threshold.pct：接受到的Block的比例，缺省为95%，就是说，必须DataNode报告的数据块数目占总数的95%，才到达门槛；  
  //dfs.replication.min：缺省为1，即每个副本都存在系统中；  
  //dfs.replication.min：等待时间，缺省为0，单位秒。  
  private SafeModeInfo safeMode;  // safe mode information  
    
  //保存了主机名（String）到DatanodeDescriptor数组的映射（Host2NodesMap唯一的成员变量为HashMap<String,DatanodeDescriptor[]> map，它的方法都是对这个map进行操作）。   
  private Host2NodesMap host2DataNodeMap = new Host2NodesMap();  
    
    
  // datanode networktoplogy  
  //  定义了HDFS的网络拓扑，网络拓扑对应选择数据块副本的位置很重要。如在一个层次型的网络中，接到同一个交换机的两个节点间的网络速度，  
  //  会比跨越多个交换机的两个节点间的速度快，但是，如果某交换机故障，那么它对接到它上面的两个节点会同时有影响，但跨越多个交换机的两个节点，这种影响会小得多  
  NetworkTopology clusterMap = new NetworkTopology();  
    
  private DNSToSwitchMapping dnsToSwitchMapping;  
    
 // for block replicas placement  
//用于为数据块备份选择目标，例如，用户写文件时，需要选择一些DataNode，作为数据块的存放位置，这时候就利用它来选择目标地址。  
//chooseTarget是ReplicationTargetChooser中最重要的方法，  
//它通过内部的一个NetworkTopology对象，计算出一个DatanodeDescriptor数组，该数组就是选定的DataNode，同时，顺序就是最佳的数据流顺序  
  ReplicationTargetChooser replicator;  
  
  //保存了系统中允许/不允许连接到NameNode的机器列表  
  private HostsFileReader hostsReader;   
    
  //  线程句柄，该线程用于检测DataNode上的Decommission进程。例如，某节点被列入到不允许连接到NameNode的机器列表中（HostsFileReader）  
  //  那么，该节点会进入Decommission状态，它上面的数据块会被复制到其它节点，复制结束后机器进入DatanodeInfo.AdminStates.DECOMMISSIONED，这台机器就可以从HDFS中撤掉。  
  private Daemon dnthread = null;  
  
  //系统能拥有的INode最大数（配置项dfs.max.objects，0为无限制）。  
  private long maxFsObjects = 0;          // maximum number of fs objects  
  
  /** 
   * The global generation stamp for this file system.  
   */  
  private final GenerationStamp generationStamp = new GenerationStamp();  
  
  // Ask Datanode only up to this many blocks to delete.  
  //  发送给DataNode删除数据块消息中，能包含的最大数据块数。比方说，如果某DataNode上有250个Block需要被删除，而这个参数是100，  
  //  那么一共会有3条删除数据块消息消息，前面两条包含了100个数据块，最后一条是50个。  
  int blockInvalidateLimit = DFSConfigKeys.DFS_BLOCK_INVALIDATE_LIMIT_DEFAULT;  
  
  // precision of access times.  
  //用于控制文件的access时间的精度，也就是说，小于这个精度的两次对文件访问，后面的那次就不做记录了。  
  private long accessTimePrecision = 0;  
  private String nameNodeHostName;  

 

   FSNamesystem初始化方法：

 

    private void initialize(NameNode nn, Configuration conf) throws IOException {  
          
        this.systemStart = now();  
          
        setConfigurationParameters(conf);  
        //读取配置文件    
          
        dtSecretManager = createDelegationTokenSecretManager(conf);  
        //读取dfs.namenode.delegation.token的相关配置    
          
          
        this.nameNodeAddress = nn.getNameNodeAddress();  
          
        this.registerMBean(conf); // register the MBean for the FSNamesystemStutus  
          
        this.dir = new FSDirectory(this, conf);  
          
        StartupOption startOpt = NameNode.getStartupOption(conf);  
          
        this.dir.loadFSImage(getNamespaceDirs(conf),  
                             getNamespaceEditsDirs(conf), startOpt);  
        //加载namenode持久化在硬盘的信息    
          
          
        long timeTakenToLoadFSImage = now() - systemStart;  
        LOG.info("Finished loading FSImage in " + timeTakenToLoadFSImage + " msecs");  
        NameNode.getNameNodeMetrics().setFsImageLoadTime(timeTakenToLoadFSImage);  
          
        //加载安全模式信息,进入安全模式    
        this.safeMode = new SafeModeInfo(conf);  
        //将block的总数设置给safemode  
        setBlockTotal();  
          
        pendingReplications = new PendingReplicationBlocks(  
                                conf.getInt("dfs.replication.pending.timeout.sec",   
                                            -1) * 1000L);  
        if (isAccessTokenEnabled) {  
          accessTokenHandler = new BlockTokenSecretManager(true,  
              accessKeyUpdateInterval, accessTokenLifetime);  
        }  
          
        //启动心跳监控的线程    
        this.hbthread = new Daemon(new HeartbeatMonitor());  
      
        //启动文件租约管理监控的线程    
        this.lmthread = new Daemon(leaseManager.new Monitor());  
          
        //启动副本监控的线程    
        this.replmon = new ReplicationMonitor();  
        this.replthread = new Daemon(replmon);  
          
        hbthread.start();  
        lmthread.start();  
        replthread.start();  
      
        //读取主机信息黑白名单  
        this.hostsReader = new HostsFileReader(conf.get("dfs.hosts",""),  
                                               conf.get("dfs.hosts.exclude",""));  
          
        //启动退役节点监控的线程    
        this.dnthread = new Daemon(new DecommissionManager(this).new Monitor(  
            conf.getInt("dfs.namenode.decommission.interval", 30),  
            conf.getInt("dfs.namenode.decommission.nodes.per.interval", 5)));  
        dnthread.start();  
      
        this.dnsToSwitchMapping = ReflectionUtils.newInstance(  
            conf.getClass("topology.node.switch.mapping.impl", ScriptBasedMapping.class,  
                DNSToSwitchMapping.class), conf);  
          
        /* If the dns to swith mapping supports cache, resolve network  
         * locations of those hosts in the include list,  
         * and store the mapping in the cache; so future calls to resolve 
         * will be fast. 
         */  
        if (dnsToSwitchMapping instanceof CachedDNSToSwitchMapping) {  
          dnsToSwitchMapping.resolve(new ArrayList<String>(hostsReader.getHosts()));  
        }  
          
        InetSocketAddress socAddr = NameNode.getAddress(conf);  
        this.nameNodeHostName = socAddr.getHostName();  
          
        //将这个类注册到监控系统    
        registerWith(DefaultMetricsSystem.INSTANCE);  
      }  

 

       从代码中可以看到，FSNamesystem的initialize方法主要的工作是：通过读取配置文件设置成员变量；创建FSDirectory并 loadFSImage；设置系统安全模式；启动一系列的后台线程monitorDaemon。其中对 loadFSImage非常重要。 Namenode会将HDFS的文件和目录元数据存储在一个叫fsimage的二进制文 件中，每次保存fsimage之后到下次保存之间的所有hdfs操作，将会记录在editlog文件中，当editlog达到一定的大小（bytes，由 fs.checkpoint.size参数定义）或从上次保存过后一定时间段过后（sec，由fs.checkpoint.period参数定 义），namenode会重新将内存中对整个HDFS的目录树和文件元数据刷到fsimage文件中。Namenode就是通过这种方式来保证HDFS中 元数据信息的安全性。当namenode重启加载fsimage时，就是按照如下格式协议从文件流中加载元数据信息。

从fsimag的存储格式可以看出，fsimage保存有如下信息：

写道

1. image head，其中包含：
a) imgVersion(int)：当前image的版本信息
b) namespaceID(int)：用来确保别的HDFS instance中的datanode不会误连上当前NN。
c) numFiles(long)：整个文件系统中包含有多少文件和目录
d) genStamp(long)：生成该image时的时间戳信息。

2.文件或目录的源数据信息，如果是目录，则包含以下信息：
a)path(String)：该目录的路径，如”/user/zhuhui/data”
b)replications(short)：副本数（目录虽然没有副本，但这里记录的目录副本数也为3）
c)mtime(long)：该目录的修改时间的时间戳信息
d)atime(long)：该目录的访问时间的时间戳信息
e)blocksize(long)：目录的blocksize都为0
f)numBlocks(int)：实际有多少个文件块，目录的该值都为-1，表示该item为目录
g)nsQuota(long)：namespace Quota值，若没加Quota限制则为-1
h)dsQuota(long)：disk Quota值，若没加限制则也为-1
i)username(String)：该目录的所属用户名
j)group(String)：该目录的所属组
k)permission(short)：该目录的permission信息，如644等，有一个short来记录。

3.如果是文件，则还会额外包含如下信息：
a)blockid(long)：属于该文件的block的blockid，
b)numBytes(long)：该block的大小
c)genStamp(long)：该block的时间戳

 

       当该文件对应的numBlocks数不为1，而是大于1时，表示该文件对应有多个block信息，此时紧接在该fsimage之后的就会有多个 blockid，numBytes和genStamp信息。因此，在namenode启动时，就需要对fsimage按照如下格式进行顺序的加载，以将 fsimage中记录的HDFS元数据信息加载到内存中。
       namenode在加载fsimage过程其实非常简单，就是从fsimage中不停的顺序读取文件和目录的元数据信息，并在内存中构建整个 namespace，此时BlocksMap中每个block对应的datanodes 列表暂时为空。当fsimage加载完毕后，整个HDFS的目录结构在内存中就已经初始化完毕，所缺的就是每个文件对应的block对应的 datanode列表信息。这些信息需要从datanode的blockReport中获取，所以加载fsimage完毕后，namenode进程进入 rpc等待状态，等待所有的datanodes发送blockReports。
    HDFS将fsimage和edits文件内容读入内存，进行合并，填充与INode相关的元数据结构，并将新的元数据内存镜像导出，在磁盘上形成新的 fsimage和edits文件。HDFS同时还接收DataNode的心跳信息，填充与Block和Data Node相关的元数据结构。
    saveNameSpace将元数据写入到磁盘，具体操作步骤：首先将current目录重命名为lastcheckpoint.tmp;然后在创建新的 current目录，并保存文件；最后将lastcheckpoint.tmp重命名为privios.checkpoint。

    在加载完成时,初始化了一下四个守护线程:

    //启动心跳监控的线程    
    this.hbthread = new Daemon(new HeartbeatMonitor());  
      
    //启动文件租约管理监控的线程    
    this.lmthread = new Daemon(leaseManager.new Monitor());  
      
    //启动副本监控的线程    
    this.replmon = new ReplicationMonitor();  
    this.replthread = new Daemon(replmon);  
      
    hbthread.start();  
    lmthread.start();  
    replthread.start();  
      
    //启动退役节点监控的线程    
    this.dnthread = new Daemon(new DecommissionManager(this).new Monitor(  
        conf.getInt("dfs.namenode.decommission.interval", 30),  
        conf.getInt("dfs.namenode.decommission.nodes.per.interval", 5)));  
    dnthread.start();  

 （2）初始化RPC服务器

 //init namenode-client RPC Server  
  this.server = RPC.getServer(this, socAddr.getHostName(),socAddr.getPort(), handlerCount, false, conf, namesystem.getDelegationTokenSecretManager());  
     
 public synchronized void start() {  
  responder.start();  
  listener.start();  
  handlers = new Handler[handlerCount];  
    
  for (int i = 0; i < handlerCount; i++) {  
    handlers[i] = new Handler(i);  
    handlers[i].start();  
  }  
}  

   server启动了三个（假设handlercount为1）线程，这三个线程分别为listener，responder，handler ，这三个线程之间是有职责关系的：Hadoop的Server采用了Java的NIO，这样的话就不需要为每一个socket连接建立一个线程，读取 socket上的数据。在Server中，只需要一个线程，就可以accept新的连接请求和读取socket上的数据，这个线程，就是 Listener。请求处理线程一般有多个，它们都是Server.Handle类的实例。它们的run方法循环地取出一个Server.Call，调用 Server.call方法，搜集结果并串行化，然后将结果放入Responder队列中。对于处理完的请求，需要将结果写回去，同样，利用NIO，只需 要一个线程，相关的逻辑在Responder里。

（3）启动Trash Emptier 线程 

    //启动垃圾清理守护线程，读取fs.trash.interval的值作为两次清理的时间间隔。默认每60分钟清理一次    
    startTrashEmptier(conf);  
      
    private void startTrashEmptier(Configuration conf) throws IOException {  
      this.emptier = new Thread(new Trash(conf).getEmptier(), "Trash Emptier");  
      this.emptier.setDaemon(true);  
      this.emptier.start();  
    }