Hadoop学习总结之二：HDFS读写过程解析

一、文件的打开

1.1、客户端

HDFS打开一个文件，需要在客户端调用DistributedFileSystem.open(Path f, int bufferSize)，其实现为：

public FSDataInputStream open(Path f, int bufferSize) throws IOException {   return new DFSClient.DFSDataInputStream(         dfs.open(getPathName(f), bufferSize, verifyChecksum, statistics)); }

其中dfs为DistributedFileSystem的成员变量DFSClient，其open函数被调用，其中创建一个DFSInputStream(src, buffersize, verifyChecksum)并返回。

在DFSInputStream的构造函数中，openInfo函数被调用，其主要从namenode中得到要打开的文件所对应的blocks的信息，实现如下：

synchronized void openInfo() throws IOException {   LocatedBlocks newInfo = callGetBlockLocations(namenode, src, 0, prefetchSize);   this.locatedBlocks = newInfo;   this.currentNode = null; }

private static LocatedBlocks callGetBlockLocations(ClientProtocol namenode,     String src, long start, long length) throws IOException {     return namenode.getBlockLocations(src, start, length); }

LocatedBlocks主要包含一个链表的List blocks，其中每个LocatedBlock包含如下信息：

• Block b：此block的信息
• long offset：此block在文件中的偏移量
• DatanodeInfo[] locs：此block位于哪些DataNode上

上面namenode.getBlockLocations是一个RPC调用，最终调用NameNode类的getBlockLocations函数。

1.2、NameNode

NameNode.getBlockLocations实现如下：

public LocatedBlocks   getBlockLocations(String src,                                         long offset,                                         long length) throws IOException {   return namesystem.getBlockLocations(getClientMachine(),                                       src, offset, length); }

namesystem是NameNode一个成员变量，其类型为FSNamesystem，保存的是NameNode的name space树，其中一个重要的成员变量为FSDirectory dir。

FSDirectory和Lucene中的FSDirectory没有任何关系，其主要包括FSImage fsImage，用于读写硬盘上的fsimage文件，FSImage类有成员变量FSEditLog editLog，用于读写硬盘上的edit文件，这两个文件的关系在上一篇文章中已经解释过。

FSDirectory还有一个重要的成员变量INodeDirectoryWithQuota rootDir，INodeDirectoryWithQuota的父类为INodeDirectory，实现如下：

public class INodeDirectory extends INode {   ……   private List children;   …… ｝

由此可见INodeDirectory本身是一个INode，其中包含一个链表的INode，此链表中，如果仍为文件夹，则是类型INodeDirectory，如果是文件，则是类型INodeFile，INodeFile中有成员变量BlockInfo blocks[]，是此文件包含的block的信息。显然这是一棵树形的结构。

FSNamesystem.getBlockLocations函数如下：

public LocatedBlocks getBlockLocations(String src, long offset, long length,     boolean doAccessTime) throws IOException {   final LocatedBlocks ret = getBlockLocationsInternal(src, dir.getFileINode(src),       offset, length, Integer.MAX_VALUE, doAccessTime);    return ret; }

dir.getFileINode(src)通过路径名从文件系统树中找到INodeFile，其中保存的是要打开的文件的INode的信息。

getBlockLocationsInternal的实现如下：

private synchronized LocatedBlocks getBlockLocationsInternal(String src,                                                      INodeFile inode,                                                      long offset,                                                      long length,                                                      int nrBlocksToReturn,                                                      boolean doAccessTime)                                                      throws IOException {   //得到此文件的block信息   Block[] blocks = inode.getBlocks();   List results = new ArrayList (blocks.length);   //计算从offset开始，长度为length所涉及的blocks   int curBlk = 0;   long curPos = 0, blkSize = 0;   int nrBlocks = (blocks[0].getNumBytes() == 0) ? 0 : blocks.length;   for (curBlk = 0; curBlk < nrBlocks; curBlk++) {     blkSize = blocks[curBlk].getNumBytes();     if (curPos + blkSize > offset) {       //当offset在curPos和curPos + blkSize之间的时候，curBlk指向offset所在的block       break;     }     curPos += blkSize;   }   long endOff = offset + length;   //循环，依次遍历从curBlk开始的每个block，直到当前位置curPos越过endOff   do {     int numNodes = blocksMap.numNodes(blocks[curBlk]);     int numCorruptNodes = countNodes(blocks[curBlk]).corruptReplicas();     int numCorruptReplicas = corruptReplicas.numCorruptReplicas(blocks[curBlk]);     boolean blockCorrupt = (numCorruptNodes == numNodes);     int numMachineSet = blockCorrupt ? numNodes :                           (numNodes - numCorruptNodes);     //依次找到此block所对应的datanode，将其中没有损坏的放入machineSet中     DatanodeDescriptor[] machineSet = new DatanodeDescriptor[numMachineSet];     if (numMachineSet > 0) {       numNodes = 0;       for(Iterator it =           blocksMap.nodeIterator(blocks[curBlk]); it.hasNext();) {         DatanodeDescriptor dn = it.next();         boolean replicaCorrupt = corruptReplicas.isReplicaCorrupt(blocks[curBlk], dn);         if (blockCorrupt || (!blockCorrupt && !replicaCorrupt))           machineSet[numNodes++] = dn;       }     }     //使用此machineSet和当前的block构造一个LocatedBlock     results.add(new LocatedBlock(blocks[curBlk], machineSet, curPos,                 blockCorrupt));     curPos += blocks[curBlk].getNumBytes();     curBlk++;   } while (curPos < endOff         && curBlk < blocks.length         && results.size() < nrBlocksToReturn);   //使用此LocatedBlock链表构造一个LocatedBlocks对象返回   return inode.createLocatedBlocks(results); }

1.3、客户端

通过RPC调用，在NameNode得到的LocatedBlocks对象，作为成员变量构造DFSInputStream对象，最后包装为FSDataInputStream返回给用户。

 

二、文件的读取

2.1、客户端

文件读取的时候，客户端利用文件打开的时候得到的FSDataInputStream.read(long position, byte[] buffer, int offset, int length)函数进行文件读操作。

FSDataInputStream会调用其封装的DFSInputStream的read(long position, byte[] buffer, int offset, int length)函数，实现如下：

public int read(long position, byte[] buffer, int offset, int length)   throws IOException {   long filelen = getFileLength();   int realLen = length;   if ((position + length) > filelen) {     realLen = (int)(filelen - position);   }   //首先得到包含从offset到offset + length内容的block列表   //比如对于64M一个block的文件系统来说，欲读取从100M开始，长度为128M的数据，则block列表包括第2，3，4块block   List blockRange = getBlockRange(position, realLen);   int remaining = realLen;   //对每一个block，从中读取内容   //对于上面的例子，对于第2块block，读取从36M开始，读取长度28M，对于第3块，读取整一块64M，对于第4块，读取从0开始，长度为36M，共128M数据   for (LocatedBlock blk : blockRange) {     long targetStar