HDFS dfsclient写文件过程

Hadoop学习<二>--HDFS文件系统操作方式 linux用户身份与群组记录的文件 cat /etc/group                查看用户组 cat /etc/shadow              查看个人密码 cat /etc/passwd              查看用户相关信息 这三个文件可以说是:账号,密码,群组    信息的的集中地! w或who                            查 阅读详情

HDFS写入文件的重要概念

HDFS一个文件由多个block构成。HDFS在进行block读写的时候是以packet(默认每个packet为64K)为单位进行的。每一个packet由若干个chunk(默认512Byte)组成。Chunk是进行数据校验的基本单位,对每一个chunk生成一个校验和(默认4Byte)并将校验和进行存储。

在写入一个block的时候,数据传输的基本单位是packet,每个packet由若干个chunk组成。

 

HDFS客户端写文件示例代码

FileSystem hdfs = FileSystem.get(new Configuration());
Path path = new Path("/testfile");

// writing
FSDataOutputStream dos = hdfs.create(path);
byte[] readBuf = "Hello World".getBytes("UTF-8");
dos.write(readBuf, 0, readBuf.length);
dos.close();

hdfs.close();

文件的打开

上传一个文件到hdfs,一般会调用DistributedFileSystem.create,其实现如下:


public FSDataOutputStream create(Path f, FsPermission permission,boolean overwrite,int bufferSize, short replication, long blockSize,Progressable progress) throws IOException {
    return new FSDataOutputStream
       (dfs.create(getPathName(f), permission,overwrite, replication, blockSize, progress, bufferSize),
        statistics);
}

其最终生成一个FSDataOutputStream用于向新生成的文件中写入数据。其成员变量dfs的类型为DFSClient,DFSClient的create函数如下:


public OutputStream create(String src,FsPermission permission,boolean overwrite,short replication,long blockSize,Progressable progress,int buffersize) throws IOException {
    checkOpen();
    if (permission == null) {
      permission = FsPermission.getDefault();
    }
    FsPermission masked = permission.applyUMask(FsPermission.getUMask(conf));
    OutputStream result = new DFSOutputStream(src, masked,overwrite, replication, blockSize, progress, buffersize,
        conf.getInt("io.bytes.per.checksum", 512));
    leasechecker.put(src, result);
    return result;
}

其中构造了一个DFSOutputStream,在其构造函数中,同过RPC调用NameNode的create来创建一个文件。 
当然,构造函数中还做了一件重要的事情,就是streamer.start(),也即启动了一个pipeline,用于写数据,在写入数据的过程中,我们会仔细分析。

DFSOutputStream(String src, FsPermission masked, boolean overwrite,short replication, long blockSize, Progressable progress,
                int buffersize, int bytesPerChecksum) throws IOException {
    this(src, blockSize, progress, bytesPerChecksum);
    computePacketChunkSize(writePacketSize, bytesPerChecksum);
    try {
      namenode.create(src, masked, clientName, overwrite, replication, blockSize);
    } catch(RemoteException re) {
      throw re.unwrapRemoteException(AccessControlException.class,QuotaExceededException.class);
    }
    streamer.start();
}

 通过rpc调用NameNode的create函数,调用namesystem.startFile函数,其又调用startFileInternal函数,它创建一个新的文件,状态为under construction,没有任何data block与之对应。


dfsclient文件的写入

下面轮到客户端向新创建的文件中写入数据了,一般会使用FSDataOutputStream的write方法:

按照hdfs的设计,对block的数据写入使用的是pipeline的方式,也即将数据分成一个个的package,如果需要复制三分,分别写入DataNode 1, 2, 3,则会进行如下的过程:

  • 首先将package 1写入DataNode 1
  • 然后由DataNode 1负责将package 1写入DataNode 2,同时客户端可以将pacage 2写入DataNode 1
  • 然后DataNode 2负责将package 1写入DataNode 3, 同时客户端可以讲package 3写入DataNode 1,DataNode 1将package 2写入DataNode 2
  • 就这样将一个个package排着队的传递下去,直到所有的数据全部写入并复制完毕

FSDataOutputStream的write方法会调用DFSOutputStream的write方法,而DFSOutputStream继承自FSOutputSummer,所以实际上是调用FSOutputSummer的write方法,如下:


public synchronized void write(byte b[], int off, int len)
  throws IOException {
    //参数检查
    for (int n=0;n<len;n+=write1(b, off+n, len-n)) {
    }
  }

FSOutputSummer的write1的方法如下:

private int write1(byte b[], int off, int len) throws IOException {
    if(count==0 && len>=buf.length) {
      // buf初始化的大小是chunk的大小,默认是512,这里的代码会在写入的数据的剩余内容大于或等于一个chunk的大小时调用
      // 这里避免多余一次复制
      final int length = buf.length;
      sum.update(b, off, length);//length是一个完整chunk的大小,默认是512,这里根据一个chunk内容计算校验和
      writeChecksumChunk(b, off, length, false);
      return length;
    }
    
    // buf初始化的大小是chunk的大小,默认是512,这里的代码会在写入的数据的剩余内容小于一个chunk的大小时调用
    // 规避了数组越界问题
    int bytesToCopy = buf.length-count;
    bytesToCopy = (len<bytesToCopy) ? len : bytesToCopy;
    sum.update(b, off, bytesToCopy);//bytesToCopy不足一个chunk,是写入的内容的最后一个chunk的剩余字节数目
    System.arraycopy(b, off, buf, count, bytesToCopy);
    count += bytesToCopy;
    if (count == buf.length) {//如果不足一个chunk,就缓存到本地buffer,如果还有下一次写入,就填充这个chunk,满一个chunk再flush,count清0
      // local buffer is full
      flushBuffer();//最终调用writeChecksumChunk方法实现
    } 
    return bytesToCopy;
  }

writeChecksumChunk的实现如下:

//写入一个chunk的数据长度(默认512),忽略len的长度
private void writeChecksumChunk(byte b[], int off, int len, boolean keep)
  throws IOException {
    int tempChecksum = (int)sum.getValue();
    if (!keep) {
      sum.reset();
    }
    int2byte(tempChecksum, checksum);//把当前chunk的校验和从int转换为字节
    writeChunk(b, off, len, checksum);
}

writeChunk由子类DFSOutputStream实现,如下:

protected synchronized void writeChunk(byte[] b, int offset, int len, byte[] checksum)throws IOException {

      //创建一个package,并写入数据
      currentPacket = new Packet(packetSize, chunksPerPacket,bytesCurBlock);
      currentPacket.writeChecksum(checksum, 0, cklen);
      currentPacket.writeData(b, offset, len);
      currentPacket.numChunks++;
      bytesCurBlock += len;

      //如果此package已满,则放入队列中准备发送
      if (currentPacket.numChunks == currentPacket.maxChunks ||bytesCurBlock == blockSize) {
          ......
          dataQueue.addLast(currentPacket);
          //唤醒等待dataqueue的传输线程,也即DataStreamer
          dataQueue.notifyAll();
          currentPacket = null;
          ......
      }
 }

writeChunk比较简单,就是把数据填充packet,填充完毕,就放到dataQueue,再唤醒DataStreamer。

DataStreamer完成了数据的传输,DataStreamer的run函数如下:

public void run() {
    while (!closed && clientRunning) {
      Packet one = null;
      synchronized (dataQueue) {
      boolean doSleep = processDatanodeError(hasError, false);//如果ack出错,则处理IO错误
        //如果队列中没有package,则等待
        while ((!closed && !hasError && clientRunning && dataQueue.size() == 0) || doSleep) {
          try {
            dataQueue.wait(1000);
          } catch (InterruptedException  e) {
          }
          doSleep = false;
        }
        try {
          //得到队列中的第一个package
          one = dataQueue.getFirst();
          long offsetInBlock = one.offsetInBlock;
          //由NameNode分配block,并生成一个写入流指向此block
          if (blockStream == null) {
            nodes = nextBlockOutputStream(src);
            response = new ResponseProcessor(nodes);
            response.start();
          }

          ByteBuffer buf = one.getBuffer();
          //将packet从dataQueue移至ackQueue,等待确认
          dataQueue.removeFirst();
          dataQueue.notifyAll();
          synchronized (ackQueue) {
            ackQueue.addLast(one);
            ackQueue.notifyAll();
          }

          //利用生成的写入流将数据写入DataNode中的block
          blockStream.write(buf.array(), buf.position(), buf.remaining());
          if (one.lastPacketInBlock) {
            blockStream.writeInt(0); //表示此block写入完毕
          }
          blockStream.flush();
        } catch (Throwable e) {
        }
        
        if (one.lastPacketInBlock) {
            //数据块写满,做一些清理工作,下次再申请块
            response.close();        // ignore all errors in Response
            
            synchronized (dataQueue) {
              IOUtils.cleanup(LOG, blockStream, blockReplyStream);
              nodes = null;
              response = null;
              blockStream = null;//设置为null,下次就会判断blockStream为null,申请新的块
              blockReplyStream = null;
            }
        }
    }
      ......
  }

DataStreamer线程负责把准备好的数据packet,顺序写入到DataNode,未确认写入成功的packet则移动到ackQueue,等待确认。

DataStreamer线程传输数据到DataNode时,要向namenode申请数据块,方法是nextBlockOutputStream,再调用locateFollowingBlock,通过RPC调用namenode.addBlock(src, clientName),在NameNode分配了DataNode和block以后,createBlockOutputStream开始写入数据。

客户端在DataStreamer的run函数中创建了写入流后,调用blockStream.write将packet写入DataNode

 

DataStreamer还会启动ResponseProcessor线程,它负责接收datanode的ack,当接收到所有datanode对一个packet确认成功的ack,ResponseProcessor从ackQueue中删除相应的packet。在出错时,从ackQueue中移除packet到dataQueue,移除失败的datanode,恢复数据块,建立新的pipeline。实现如下:

public void run() {
...
PipelineAck ack = new PipelineAck();
while (!closed && clientRunning && !lastPacketInBlock) {
  try {
    // read an ack from the pipeline
    ack.readFields(blockReplyStream);
    ...
    //处理所有DataNode响应的状态
    for (int i = ack.getNumOfReplies()-1; i >=0 && clientRunning; i--) {
        short reply = ack.getReply(i);  
      if (reply != DataTransferProtocol.OP_STATUS_SUCCESS) {//ack验证,如果DataNode写入packet失败,则出错    
        errorIndex = i; //记录损坏的DataNode,会在processDatanodeError方法移除该失败的DataNode
        throw new IOException("Bad response " + reply + " for block " + block +  " from datanode " + targets[i].getName());    
      }   
    }

    long seqno = ack.getSeqno();
    if (seqno == Packet.HEART_BEAT_SEQNO) {  // 心跳ack,忽略
      continue;
    }
    Packet one = null;
    synchronized (ackQueue) {
      one = ackQueue.getFirst();
    }
    ...
    synchronized (ackQueue) {
      assert ack.getSeqno() == lastAckedSeqno + 1;//验证ack
      lastAckedSeqno = ack.getSeqno();
      ackQueue.removeFirst();//移除确认写入成功的packet
      ackQueue.notifyAll();
    }
  } catch (Exception e) {
    if (!closed) {
      hasError = true;//设置ack错误,让
      ...
      closed = true;
    }
  }
}
}

当ResponseProcessor在确认packet失败时,processDatanodeError方法用于处理datanode的错误,当调用返回后需要休眠一段时间时,返回true。下面是其简单的处理流程:

1.关闭blockStream和blockReplyStream
2.将packet从ackQueue移到dataQueue
3.删除坏datanode
4.通过RPC调用datanode的recoverBlock方法来恢复块,如果有错,返回true
5.如果没有可用的datanode,关闭DFSOutputStream和streamer,返回false
6.创建块输出流,如果不成功,转到3

实现如下:

private boolean processDatanodeError(boolean hasError, boolean isAppend) {
  if (!hasError) {//DataNode没有发生错误,直接返回
    return false;
  }
  
  //将未确认写入成功的packets从ack queue移动到data queue的前面
  synchronized (ackQueue) {
    dataQueue.addAll(0, ackQueue);
    ackQueue.clear();
  }

  boolean success = false;
  while (!success && clientRunning) {
    DatanodeInfo[] newnodes = null;
    
    //根据errorIndex确定失败的DataNode,从所有的DataNode nodes移除失败的DataNode,复制到newnodes

    // 通知primary datanode做数据块恢复,更新合适的时间戳
    LocatedBlock newBlock = null;
    ClientDatanodeProtocol primary =  null;
    DatanodeInfo primaryNode = null;
    try {
      // Pick the "least" datanode as the primary datanode to avoid deadlock.
      primaryNode = Collections.min(Arrays.asList(newnodes));
      primary = createClientDatanodeProtocolProxy(primaryNode, conf, block, accessToken, socketTimeout);
      newBlock = primary.recoverBlock(block, isAppend, newnodes);//恢复数据块
    } catch (IOException e) {
        //循环创建块输出流,如果不成功,移除失败的DataNode
          return true;          // 需要休眠
    } finally {
      RPC.stopProxy(primary);
    }
    recoveryErrorCount = 0; // 数据块恢复成功
    block = newBlock.getBlock();
    accessToken = newBlock.getBlockToken();
    nodes = newBlock.getLocations();

    this.hasError = false;
    lastException = null;
    errorIndex = 0;
    success = createBlockOutputStream(nodes, clientName, true);
  }

  response = new ResponseProcessor(nodes);
  response.start();//启动ResponseProcessor做ack确认处理
  return false; // 不休眠,继续处理
}

总结 

hdfs文件的写入是比较复杂的,所以本文重点介绍了dfsclient端的处理逻辑,对namenode和datanode的响应,就不做详细分析了。

更多参考

      http://www.cnblogs.com/forfuture1978/archive/2010/11/10/1874222.html (HDFS读写过程解析)

      http://blog.jeoygin.org/2012/07/hdfs-source-analysis-hdfs-input-output-stream.html (讲解dfsclient的重要类的职责)

      http://caibinbupt.iteye.com/blog/286259 (datanode对于块写入的处理)


hdfs源码解析之DFSClient 该构造函数已废弃,接受一个Configuration对象,并调用另一个构造函数获取NameNode地址该构造函数接受一个InetSocketAddress对象和一个Configuration对象,并将InetSocketAddress 转换为URI然后调用另一个基于URI的构造函数该构造函数接受一个URI对象和一个Configuration对象,并将FileSystem.Statistics参数设置为 null,然后调用另一个更完整的构造函数。 阅读详情

相关推荐

从零到一:Livox Mid-360 激光雷达的硬件集成与避坑实战

本文详细介绍了Livox Mid-360激光雷达的硬件集成全流程,包括硬件准备、网络配置、驱动编译和常见问题解决方案。通过实战经验,帮助开发者高效完成从设备拆箱到数据输出的完整链路,避免在IP设置、驱动编译和固件兼容性等环节踩坑。

salt的博客 1031

HDFS DeadNode Detection机制

文章目录前言HDFS DFSClient现有DeadNode监测DFSClient共享DeadNode的监测和恢复引用 前言 在大规模集群中,节点挂掉的现象是十分常见。当节点挂掉的时候,上面所跑的任务或者发送到这个节点的请求将会失败。按照分布式系统的正常处理方法,它会选择另外的节点进行重新的数据请求。这种重试机制在一定程度上可以解决因为节点意外挂掉导致的请求失败情况,但是这种方式并不是高效的。假...

走在前往架构师的路上 1650

RocketMq面板访问异常 com.alibaba.fastjson.JSONException: not close json text, token : string

rocketmq JSONException: not close json text, token : string 问题解决

qq_21067307的博客 5575

HDFS dfsclient写文件过程 源码分析

HDFS写入文件的重要概念 HDFS一个文件由多个block构成。HDFS在进行block读写的时候是以packet(默认每个packet为64K)为单位进行的。每一个packet由若干个chunk(默认512Byte)组成。Chunk是进行数据校验的基本单位,对每一个chunk生成一个校验和(默认4Byte)并将校验和进行存储。 在写入一个block的时候,数据传输的基本单位是packet,...

weixin_33828101的博客 271

深度学习 tesorflow2.0版本 入门第一章

为什么要学tensflow 深度学习发展迅猛 框架灵活 google开发 公司应用广泛 2.0更加灵活 后面会学习的项目 图像分类 房价预测 泰坦尼克号生存预测 文本分类 文本生成 机器翻译 核心部分 模型训练 tesorboard----> 查看模型训练进度 模型保存和部署 分布式训练-----> 加速训练速度,提升训练效率 TensorFlow常用库:Tfds, tfhub,tensor2tensor 多平台云端环境GPU:Goolgle cloud环境配置,AWS环境配置 kaggle平

weixin_46969441的博客 1238

Dify保姆级教程:从零搭建AI知识库,让大模型真正懂你的文档

通用大模型的知识边界来自公开语料,面对企业内部制度、产品手册等私有内容,往往只能靠“猜”,由此产生幻觉。要解决这个问题,需要借助检索增强生成(RAG)技术,为模型配置一个外挂资料库。RAG的原理类似开卷考试:先对文档进行文本切分、向量化,再在提问时检索语义相关的片段,交由大模型生成答案。Dify作为开源AI知识库平台,将文档导入、分段设置、向量索引、召回测试等复杂链路封装成可视化操作,让产品经理、运营等非研发人员也能独立搭建企业级问答助手。本文从环境部署、模型接入、参数调优到多知识库维护,完整覆盖一条可落地

weixin_29039773的博客 221

Hadoop-HDFS写文件

分享一个大牛的人工智能教程。零基础!通俗易懂!风趣幽默!希望你也加入到人工智能的队伍中来!请点击http://www.captainbed.net 1、客户端将文件写入本地磁盘的 HDFS Client 文件中。 2、当临时文件大小达到一个 Block 大小时,HDFS Client 通知 NameNode,申请写入文件。 3、NameNode 在 HDFS 的文件系统中创建一个文件,并把该 Block Id 和要写入的 DataNode 的列表返回给客户端。 4、客户端收到这些信息后,将临时文

了解➔熟悉➔掌握➔精通 3万+

定时器(PWM输出)触发ADC采样(DMA)——STM32CubeMX

已知 Tclk 为 84MHz , 我们需要 Tout 为 200ms 即 200000us , 不妨先让PSC为 839, 带入上述公式可得 ARR = 19999. 这样算出来之后ARR和PSC都在0~65535的范围, 则可以使用这组参数。例如,如果时钟频率为1MHz,并且PSC设置为1000,则实际的定时频率将为1kHz。当重装载值(Period 或 ARR)设置为 500 时,意味着定时器需要计数 500 个时钟周期才会触发中断。例如,如果时钟频率为1MHz,则Tclk为1微秒。

2301_77123899的博客 1万+

HDFS写详解 block、packet与chunk

block、packet与chunk 在DFSClient写HDFS的过程中,有三个需要搞清楚的单位:block、packet与chunk; block是最大的一个单位,它是最终存储于DataNode上的数据粒度,由dfs.block.size参数决定,默认是64M;注:这个参数由客户端配置决定; packet是中等的一个单位,它是数据由DFSClient流向DataNode的粒度,以dfs.write.packet.size参数为参考值,默认是64K;注:这个参数为参考值,是指真正在进行数据传输时,会以

qq_36382679的博客 655

麒麟OS恢复出厂设置原理与实操:非重装的系统状态回滚

Linux操作系统中的‘恢复出厂设置’并非简单重装或镜像还原,而是一种基于状态快照、包管理与配置模板的可控回滚机制。其核心原理依赖LVM快照技术、RPM包签名验证和预置配置模板,兼顾系统稳定性与用户数据安全。该方案在政务、教育等国产化场景中具有显著技术价值——不格式化硬盘、不丢失/home文档、不重配驱动与授权,大幅降低运维复杂度。典型应用场景包括系统卡顿修复、软件冲突清理、桌面环境异常恢复等。本文深入解析银河麒麟V10的kylin-restore-cli工具链与麒麟管家集成逻辑,聚焦‘恢复出厂设置’这一高

weixin_30879169的博客 782

AutoSAR系列讲解(入门篇)4.1-BSW概述

BSW概述,主要讲解BSW的结构组成

雪云飞星的博客 4万+

hdfs写数据过程

HDFS(Hadoop Distributed File System,Hadoop分布式文件系统)是Hadoop生态系统中的核心组件,它负责分布式存储大量数据,并确保数据的高可靠性、容错性和高吞吐量。HDFS是基于Google的GFS(Google File System)设计的,用于在廉价的商用硬件上存储大量数据。它将文件分割成多个数据块,分布存储在集群的不同节点上,并为每个数据块保留多个副本,以防止节点故障导致的数据丢失。

Flying_Fish_roe的博客 1167

Python数据分析师必备:OpenClaw开启Pandas清洗脚本自动生成新时代

本文介绍了OpenClaw这一AI智能体框架如何帮助Python数据分析师高效完成数据清洗工作。OpenClaw通过自然语言交互理解用户需求,自动生成Pandas清洗脚本,显著提升了数据清洗效率,降低了技术门槛。文章详细阐述了OpenClaw的工作原理、实战应用步骤及其在电商、金融、医疗等行业中的成功案例。相比传统手动编写脚本方式,OpenClaw能快速生成规范准确的清洗代码,使数据分析师能更专注于业务洞察。该工具为数据驱动决策提供了可靠支持,是数据分析领域的重要创新。

远程部署调试 运行安装 项目调试 二次开发 项目技术新 持续迭代 部分源码免费分享 232

hadoop源码解析之hdfs写数据全流程分析---创建文件

概述 DFSClient创建文件 namenode创建文件 概述hdfs中写数据应该是hdfs中最复杂的业务之一了,hadoop中的每个文件由多个block组成,每个块又有多个备份,这些备份又放在了不同的机器上,所以新建文件的时候会向namenode申请block所在的机器。hdfs中每个block默认情况下是128M,由于每个块比较大,所以在写数据的过程中是把数据块拆分成一个个的数据包以管道的形式

公众号[大数据技术与应用实战],分享大数据实战案例 2082

NTscan扫描工具

ntscan是一个扫描器,可以扫描没有密码和弱密码的共享,先到配置文件中填写猜测的用户名和密码,扫描过程中右侧出现的是扫描日志。

WINCC7.3破解文件

WINCC7.3硬件够破解文件,有需要的下载!WINCC7.3硬件够破解文件,有需要的下载!

HDFS文件上传之create创建过程-尚硅谷大数据培训

2)Ctrl+h查找create实现类,点击NameNodeRpcServer,在NameNodeRpcServer.java中搜索create。点击newStreamForCreate方法中的out.start(),进入DFSOutputStream.java。点击newStreamForCreate,进入DFSOutputStream.java。点击DataStreamer,进入DataStreamer.java。点击create,进入DFSClient.java。1)点击create。...

zjjcchina的博客 488

visio安装包

Microsoft Office Visio 是一款专业的制图软件。利用经过更新的形状、协作工具和数据链接图表,创建专业级图表以简化复杂的信息。

hadoop源码 - dfsclient写文件过程

HDFS写入文件的重要概念 HDFS一个文件由多个block构成。HDFS在进行block读写的时候是以packet(默认每个packet为64K)为单位进行的。每一个packet由若干个chunk(默认512Byte)组成。Chunk是进行数据校验的基本单位,对每一个chunk生成一个校验和(默认4Byte)并将校验和进行存储。 在写入一个block的时候,数据传输的基本单位是packet,

Mrknowledge 1070

锂电池充电器电路设计 里面有电路

锂电池充电器电路设计 里面有电路 3.7V升压到5V电路设计。

Hadoop日记Day11---主从节点接口分析

一、NameNode 的接口分析 1. NameNode本质   经过前面的学习,可以知道NameNode 本身就是一个java 进程。观察RPC.getServer()方法的第一个参数,发现是this,说明NameNode 本身就是一个位于服务端的被调用对象,即NameNode 中的方法是可以被客户端代码调用的。根据RPC 运行原理可知,NameNode暴露给客户端的方法是位于接口中的。我们...

weixin_34337381的博客 95

hdfs源码分析第二弹

hdfs源码分析第二弹  以写文件为例,串联整个流程的源码: FSDataOutputStream out = fs.create(outFile); 1. DistributedFileSystem 继承并实现了FileSystem,该对象是终端用户和hadoop分布式文件系统交互的接口。 原文说明: /*****************************

张伟的专栏 502

Hbase写入hdfs源码分析

版权声明:本文由熊训德原创文章,转载请注明出处:文章原文链接:https://www.qcloud.com/community/article/258 来源:腾云阁https://www.qcloud.com/community 本文档从源码角度分析了,hbase作为dfs client写入hdfs的hadoop sequence文件最终刷盘落地的过程。之前在《wal线程模型源码分析...

weixin_30888707的博客 65

hdfs写文件过程

作者:Liao hongshen 关于hadoop写文件的过程的一个描述; 首先附图(hadoop指南中)。 关于会上讨论的数据写入一致性,真实的过程和刘喆描述是相同的,由DFSClient向第一个datanode(从namenode申请)中建立dataoutputstream,在这个中会写入复制datanode的头信息;Datanode中的DataXcev

bertzhang的专栏 2485
上一篇: Hadoop 2.0稳定版本2.2.0新特性剖析
下一篇: Hadoop读写文件时内部工作机制
迷途小码
博客等级 码龄19年 71粉丝 95原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值