如何用NetCDF-java高效读取含结构类型的HDF5栅格变量

待处理的HDF5文件中，栅格变量结构如下：

Structure {
  float depth;
  float uncertainty;
} values(2115, 1635);
:_ChunkSizes = 67U, 103U; // uint

我使用NetCDF-java 5.6.0版本处理这类结构变量时，代码运行极慢（处理上述数据耗时36分钟），但用JHDF库仅需约2秒。此前处理简单栅格变量时无此问题，推测是API使用方式有误——原代码逐元素读取结构，导致大量短生命周期对象和频繁文件访问。原代码如下：

NetcdfFile ncfile = NetcdfFiles.open(targetFilePath);
Variable v = ncfile.findVariable(targetVariableName);
System.out.println(""+v.toString());
Structure s = (Structure) v;
v.setCaching(true);  // 无明显效果
int[] shape = s.getShape();
StructureData sd = s.readStructure(0);
Member m = sd.findMember("depth");
double sumValid = 0;
int nValid = 0;
int nNoData = 0;
for (int i = 0; i < shape[0]; i++) {
  for (int j = 0; j < shape[1]; j++) {
    int index = i * shape[1] + j;
    sd = s.readStructure(index);
    float[] f = sd.getJavaArrayFloat(m);
    if (f[0] == 1000000) {
      nNoData++;
    } else {
      sumValid += f[0];
      nValid++;
    }
  }
}
System.out.println("nValid:  " + nValid);
System.out.println("nNoData: " + nNoData);
System.out.println("Mean:    " + (sumValid / nValid));

优化方案 #

核心思路是避免逐元素读取整个结构，直接将结构内的目标成员（如depth）作为独立变量处理，利用NetCDF的批量读取机制减少IO次数和对象开销。

方案1：一次性读取整个成员变量（内存充足时） #

直接提取depth成员对应的变量，批量读取其全部数据，效率最高：

try (NetcdfFile ncfile = NetcdfFiles.open(targetFilePath)) {
    Structure s = (Structure) ncfile.findVariable(targetVariableName);
    // 将结构成员转为独立变量
    Variable depthVar = s.findMember("depth").toVariable();
    int[] shape = depthVar.getShape();

    // 一次性读取整个二维浮点数数组
    ArrayFloat.D2 depthArray = (ArrayFloat.D2) depthVar.read();

    double sumValid = 0;
    int nValid = 0;
    int nNoData = 0;

    // 遍历数组计算统计值
    for (int i = 0; i < shape[0]; i++) {
        for (int j = 0; j < shape[1]; j++) {
            float value = depthArray.get(i, j);
            if (value == 1000000) {
                nNoData++;
            } else {
                sumValid += value;
                nValid++;
            }
        }
    }

    System.out.println("nValid:  " + nValid);
    System.out.println("nNoData: " + nNoData);
    System.out.println("Mean:    " + (sumValid / nValid));
} catch (IOException e) {
    e.printStackTrace();
}

方案2：按Chunk分块读取（内存有限时） #

匹配HDF5文件的Chunk大小（67x103）分块读取，既控制内存占用，又保证IO效率：

try (NetcdfFile ncfile = NetcdfFiles.open(targetFilePath)) {
    Structure s = (Structure) ncfile.findVariable(targetVariableName);
    Variable depthVar = s.findMember("depth").toVariable();
    int[] shape = depthVar.getShape();
    // 匹配文件的Chunk尺寸
    int chunkRowSize = 67;
    int chunkColSize = 103;

    double sumValid = 0;
    int nValid = 0;
    int nNoData = 0;

    // 分块遍历读取
    for (int iStart = 0; iStart < shape[0]; iStart += chunkRowSize) {
        int iEnd = Math.min(iStart + chunkRowSize, shape[0]);
        for (int jStart = 0; jStart < shape[1]; jStart += chunkColSize) {
            int jEnd = Math.min(jStart + chunkColSize, shape[1]);
            // 定义读取范围：起始索引和读取数量
            int[] start = {iStart, jStart};
            int[] count = {iEnd - iStart, jEnd - jStart};
            ArrayFloat.D2 chunk = (ArrayFloat.D2) depthVar.read(start, count);

            // 遍历当前块
            for (int i = 0; i < chunk.getShape()[0]; i++) {
                for (int j = 0; j < chunk.getShape()[1]; j++) {
                    float value = chunk.get(i, j);
                    if (value == 1000000) {
                        nNoData++;
                    } else {
                        sumValid += value;
                        nValid++;
                    }
                }
            }
        }
    }

    System.out.println("nValid:  " + nValid);
    System.out.println("nNoData: " + nNoData);
    System.out.println("Mean:    " + (sumValid / nValid));
} catch (IOException e) {
    e.printStackTrace();
}

优化说明 #

1. 减少IO次数：原代码每次循环发起一次文件读取，优化后仅需数次（分块）或一次（整变量）IO，大幅降低磁盘开销。
2. 降低对象开销：避免了频繁创建StructureData等临时对象，减少GC压力。
3. 利用NetCDF缓存：批量读取时NetCDF会自动利用缓存机制，进一步提升性能。

内容的提问来源于stack exchange，提问作者Gary Lucas