大量文件的快速 Linux 文件计数

Question

当存在大量文件（超过 100,000 个）时，我正在尝试找出在特定目录中查找文件数量的最佳方法。

当有那么多文件时，执行ls | wc -l 需要很长时间才能执行。我相信这是因为它返回了所有文件的名称。我正在尝试尽可能少地占用磁盘 I/O。

我尝试了一些 shell 和 Perl 脚本，但无济于事。我该怎么做？

Answer 1

默认情况下ls 对名称进行排序，如果名称很多，这可能需要一段时间。在所有名称都被读取和排序之前，也不会有输出。使用ls -f 选项关闭排序。

ls -f | wc -l

注意：这也会启用-a，所以.、..和其他以.开头的文件都会被计算在内。

Answer 2

最快的方法是专门构建的程序，如下所示：

#include <stdio.h>
#include <dirent.h>

int main(int argc, char *argv[]) {
    DIR *dir;
    struct dirent *ent;
    long count = 0;

    dir = opendir(argv[1]);

    while((ent = readdir(dir)))
            ++count;

    closedir(dir);

    printf("%s contains %ld files\n", argv[1], count);

    return 0;
}

在不考虑缓存的情况下进行的测试中，我一遍又一遍地针对同一个目录运行了大约 50 次，以避免基于缓存的数据倾斜，我得到了大致以下性能数据（在实时时钟时间):

ls -1  | wc - 0:01.67
ls -f1 | wc - 0:00.14
find   | wc - 0:00.22
dircnt | wc - 0:00.04

最后一个，dircnt，是从上述源码编译的程序。

编辑 2016-09-26

由于大众的需求，我把这个程序重写为递归的，所以它会放到子目录中，继续分别统计文件和目录。

由于很明显有些人想知道如何来完成所有这些工作，因此我在代码中添加了很多 cmets 来尝试让所发生的事情一目了然。我编写了这个并在 64 位 Linux 上对其进行了测试，但它应该适用于任何符合 POSIX 的系统，包括 Microsoft Windows。欢迎提交错误报告；如果您无法让它在您的 AIX 或 OS/400 或其他任何设备上运行，我很乐意更新它。

如您所见，它比原来的要复杂得多，而且必然如此：至少必须存在一个函数才能递归调用，除非您希望代码变得非常复杂（例如管理子目录堆栈并在单个循环中处理）。由于我们必须检查文件类型，不同操作系统、标准库等之间的差异会发挥作用，所以我编写了一个程序，试图在任何可以编译的系统上使用。

几乎没有错误检查，count 函数本身并不真正报告错误。唯一可能真正失败的调用是opendir 和stat（如果你不走运并且有一个dirent 已经包含文件类型的系统）。我对检查子目录路径名的总长度并不偏执，但理论上，系统不应允许任何长于PATH_MAX 的路径名。如果有问题，我可以解决这个问题，但只是需要向学习编写 C 的人解释更多代码。这个程序旨在作为如何递归地深入子目录的示例。

#include <stdio.h>
#include <dirent.h>
#include <string.h>
#include <stdlib.h>
#include <limits.h>
#include <sys/stat.h>

#if defined(WIN32) || defined(_WIN32) 
#define PATH_SEPARATOR '\\' 
#else
#define PATH_SEPARATOR '/' 
#endif

/* A custom structure to hold separate file and directory counts */
struct filecount {
  long dirs;
  long files;
};

/*
 * counts the number of files and directories in the specified directory.
 *
 * path - relative pathname of a directory whose files should be counted
 * counts - pointer to struct containing file/dir counts
 */
void count(char *path, struct filecount *counts) {
    DIR *dir;                /* dir structure we are reading */
    struct dirent *ent;      /* directory entry currently being processed */
    char subpath[PATH_MAX];  /* buffer for building complete subdir and file names */
    /* Some systems don't have dirent.d_type field; we'll have to use stat() instead */
#if !defined ( _DIRENT_HAVE_D_TYPE )
    struct stat statbuf;     /* buffer for stat() info */
#endif

/* fprintf(stderr, "Opening dir %s\n", path); */
    dir = opendir(path);

    /* opendir failed... file likely doesn't exist or isn't a directory */
    if(NULL == dir) {
        perror(path);
        return;
    }

    while((ent = readdir(dir))) {
      if (strlen(path) + 1 + strlen(ent->d_name) > PATH_MAX) {
          fprintf(stdout, "path too long (%ld) %s%c%s", (strlen(path) + 1 + strlen(ent->d_name)), path, PATH_SEPARATOR, ent->d_name);
          return;
      }

/* Use dirent.d_type if present, otherwise use stat() */
#if defined ( _DIRENT_HAVE_D_TYPE )
/* fprintf(stderr, "Using dirent.d_type\n"); */
      if(DT_DIR == ent->d_type) {
#else
/* fprintf(stderr, "Don't have dirent.d_type, falling back to using stat()\n"); */
      sprintf(subpath, "%s%c%s", path, PATH_SEPARATOR, ent->d_name);
      if(lstat(subpath, &statbuf)) {
          perror(subpath);
          return;
      }

      if(S_ISDIR(statbuf.st_mode)) {
#endif
          /* Skip "." and ".." directory entries... they are not "real" directories */
          if(0 == strcmp("..", ent->d_name) || 0 == strcmp(".", ent->d_name)) {
/*              fprintf(stderr, "This is %s, skipping\n", ent->d_name); */
          } else {
              sprintf(subpath, "%s%c%s", path, PATH_SEPARATOR, ent->d_name);
              counts->dirs++;
              count(subpath, counts);
          }
      } else {
          counts->files++;
      }
    }

/* fprintf(stderr, "Closing dir %s\n", path); */
    closedir(dir);
}

int main(int argc, char *argv[]) {
    struct filecount counts;
    counts.files = 0;
    counts.dirs = 0;
    count(argv[1], &counts);

    /* If we found nothing, this is probably an error which has already been printed */
    if(0 < counts.files || 0 < counts.dirs) {
        printf("%s contains %ld files and %ld directories\n", argv[1], counts.files, counts.dirs);
    }

    return 0;
}

编辑 2017-01-17

我已经合并了@FlyingCodeMonkey 建议的两个更改：

1. 使用lstat 而不是stat。如果您正在扫描的目录中有符号链接目录，这将改变程序的行为。以前的行为是（链接的）子目录将其文件计数添加到总计数中；新行为是链接目录将计为单个文件，其内容将不计入。
2. 如果文件的路径太长，则会发出错误消息并停止程序。

编辑 2017-06-29

运气好的话，这将是此答案的最后编辑:)

我已将此代码复制到 GitHub repository 中，以便更轻松地获取代码（而不是复制/粘贴，您只需 download the source），而且它使任何人都可以更轻松地提出修改建议通过从 GitHub 提交拉取请求。

源代码在 Apache 许可证 2.0 下可用。补丁^*欢迎！

---

• “补丁”就是像我这样的老人所说的“拉取请求”。

Answer 3

使用find。例如：

find . -name "*.ext" | wc -l

Answer 4

find、ls 和 perl 测试 40,000 个文件具有相同的速度（虽然我没有尝试清除缓存）：

[user@server logs]$ time find . | wc -l
42917

real    0m0.054s
user    0m0.018s
sys     0m0.040s

[user@server logs]$ time /bin/ls -f | wc -l
42918

real    0m0.059s
user    0m0.027s
sys     0m0.037s

同时使用 Perl 的 opendir 和 readdir：

[user@server logs]$ time perl -e 'opendir D, "."; @files = readdir D; closedir D; print scalar(@files)."\n"'
42918

real    0m0.057s
user    0m0.024s
sys     0m0.033s

注意：我使用 /bin/ls -f 来确保绕过 可能 稍微慢一点的别名选项和 -f 以避免文件排序。 ls 没有 -f 比 find/perl 慢两倍 除非ls与-f一起使用，似乎是同一时间：

[user@server logs]$ time /bin/ls . | wc -l
42916

real    0m0.109s
user    0m0.070s
sys     0m0.044s

我也想要一些脚本来直接询问文件系统，而不需要所有不必要的信息。

_{测试基于Peter van der Heijden、glenn jackman和mark4o的答案。}

Answer 5

令我惊讶的是，一个简单的发现与 ls -f 非常相似

> time ls -f my_dir | wc -l
17626

real    0m0.015s
user    0m0.011s
sys     0m0.009s

对

> time find my_dir -maxdepth 1 | wc -l
17625

real    0m0.014s
user    0m0.008s
sys     0m0.010s

当然，每次执行这些操作时，小数点后第三位的值都会移动一点，因此它们基本上是相同的。但请注意，find 返回一个额外的单元，因为它计算实际目录本身（并且，如前所述，ls -f 返回两个额外的单元，因为它也计算 . 和 ..）。

Answer 6

快速的 Linux 文件计数

我所知道的最快的 Linux 文件计数是

locate -c -r '/home'

不需要调用grep！但如前所述，您应该有一个新的数据库（每天由 cron 作业更新，或由 sudo updatedb 手动更新）。

来自人工定位

-c, --count
    Instead  of  writing  file  names on standard output, write the number of matching
    entries only.

附加，你应该知道它也将目录计为文件！

---

顺便说一句：如果您想了解系统类型上的文件和目录的概览

locate -S

输出目录、文件等的数量

Answer 7

您可以根据您的要求更改输出，但这是我编写的一个 Bash 单行程序，用于递归计算和报告一系列数字命名目录中的文件数。

dir=/tmp/count_these/ ; for i in $(ls -1 ${dir} | sort -n) ; { echo "$i => $(find ${dir}${i} -type f | wc -l),"; }

这会递归查找给定目录中的所有文件（不是目录），并以类似哈希的格式返回结果。对 find 命令的简单调整可以使您要计算的文件类型更具体，等等。

结果如下：

1 => 38,
65 => 95052,
66 => 12823,
67 => 10572,
69 => 67275,
70 => 8105,
71 => 42052,
72 => 1184,

Answer 8

ls 花费更多时间对文件名进行排序。使用-f禁用排序，这样会节省一些时间：

ls -f | wc -l

或者你可以使用find:

find . -type f | wc -l

Answer 9

您可以使用tree 程序获取文件和目录的数量。

运行命令tree | tail -n 1 以获取最后一行，这将显示类似“763 个目录，9290 个文件”的内容。这会递归计算文件和文件夹，不包括隐藏文件，可以使用标志-a 添加。作为参考，在我的计算机上，tree 花了 4.8 秒来计算我的整个主目录，即 24,777 个目录，238,680 个文件。 find -type f | wc -l 花了 5.3 秒，多半秒，所以我认为 tree 在速度方面很有竞争力。

只要您没有任何子文件夹，tree 是一种快速简便的文件计数方法。

另外，纯粹为了好玩，您可以使用tree | grep '^├' 仅显示当前目录中的文件/文件夹 - 这基本上是ls 的一个慢得多的版本。

Answer 10

您应该使用“getdents”代替 ls/find

这是一篇非常好的文章，描述了 getdents 方法。

http://be-n.com/spw/you-can-list-a-million-files-in-a-directory-but-not-with-ls.html

摘录如下：

ls 以及几乎所有其他列出目录的方法（包括 Python 的 os.listdir 和 find .）都依赖于 libc readdir()。但是，readdir() 一次只能读取 32K 的目录条目，这意味着如果您在同一个目录中有很多文件（例如，5 亿个目录条目），那么读取所有目录将花费非常长的时间。目录条目，尤其是在慢速磁盘上。对于包含大量文件的目录，您需要比依赖 readdir() 的工具更深入地挖掘。您需要直接使用 getdents() 系统调用，而不是来自 C standard library 的辅助方法。

我们可以从here找到使用getdents()列出文件的C代码：

为了快速列出目录中的所有文件，您需要进行两项修改。

首先，将缓冲区大小从 X 增加到 5 兆字节。

#define BUF_SIZE 1024*1024*5

然后修改主循环，它打印出目录中每个文件的信息以跳过 inode == 0 的条目。我通过添加来做到这一点

if (dp->d_ino != 0) printf(...);

在我的例子中，我也只关心目录中的文件名，所以我还重写了 printf() 语句，只打印文件名。

if(d->d_ino) printf("%sn ", (char *) d->d_name);

编译它（它不需要任何外部库，所以超级简单）

gcc listdir.c -o listdir

现在运行

./listdir [directory with an insane number of files]

Answer 11

对于非常大、非常嵌套的目录，这里的答案比此页面上的几乎所有其他内容都要快：

https://serverfault.com/a/691372/84703

locate -r '.' | grep -c "^$PWD"

Answer 12

如果在Perl 中使用opendir() 和readdir() 更快，您可以尝试。有关这些功能的示例，请查看 here。

Answer 13

我是在尝试计算包含大约 10,000 个文件夹（每个文件夹大约 10,000 个文件）的数据集中的文件时来到这里的。许多方法的问题在于它们隐含地统计了 1 亿个文件，这需要很长时间。

我冒昧地扩展了the approach by Christopher Schultz，因此它支持通过参数传递目录（他的递归方法也使用 stat）。

将以下内容放入文件dircnt_args.c：

#include <stdio.h>
#include <dirent.h>

int main(int argc, char *argv[]) {
    DIR *dir;
    struct dirent *ent;
    long count;
    long countsum = 0;
    int i;

    for(i=1; i < argc; i++) {
        dir = opendir(argv[i]);
        count = 0;
        while((ent = readdir(dir)))
            ++count;

        closedir(dir);

        printf("%s contains %ld files\n", argv[i], count);
        countsum += count;
    }
    printf("sum: %ld\n", countsum);

    return 0;
}

在gcc -o dircnt_args dircnt_args.c 之后，您可以像这样调用它：

dircnt_args /your/directory/*

在 10,000 个文件夹中的 1 亿个文件上，上述完成速度非常快（第一次运行大约 5 分钟，缓存后续：大约 23 秒）。

在不到一个小时内完成的唯一其他方法是ls，缓存时间约为 1 分钟：ls -f /your/directory/* | wc -l。但是，每个目录的计数会减少几个换行符...

与预期不同的是，我对find 的尝试在一个小时内都没有返回：-/

Answer 14

Linux 上最快的方法（问题标记为 Linux）是使用直接系统调用。这是一个计算目录中文件（仅，无目录）的小程序。您可以计算数百万个文件，它比“ls -f”快约 2.5 倍，比 Christopher Schultz's answer 快约 1.3-1.5 倍。

#define _GNU_SOURCE
#include <dirent.h>
#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/syscall.h>

#define BUF_SIZE 4096

struct linux_dirent {
    long d_ino;
    off_t d_off;
    unsigned short d_reclen;
    char d_name[];
};

int countDir(char *dir) {

    int fd, nread, bpos, numFiles = 0;
    char d_type, buf[BUF_SIZE];
    struct linux_dirent *dirEntry;

    fd = open(dir, O_RDONLY | O_DIRECTORY);
    if (fd == -1) {
        puts("open directory error");
        exit(3);
    }
    while (1) {
        nread = syscall(SYS_getdents, fd, buf, BUF_SIZE);
        if (nread == -1) {
            puts("getdents error");
            exit(1);
        }
        if (nread == 0) {
            break;
        }

        for (bpos = 0; bpos < nread;) {
            dirEntry = (struct linux_dirent *) (buf + bpos);
            d_type = *(buf + bpos + dirEntry->d_reclen - 1);
            if (d_type == DT_REG) {
                // Increase counter
                numFiles++;
            }
            bpos += dirEntry->d_reclen;
        }
    }
    close(fd);

    return numFiles;
}

int main(int argc, char **argv) {

    if (argc != 2) {
        puts("Pass directory as parameter");
        return 2;
    }
    printf("Number of files in %s: %d\n", argv[1], countDir(argv[1]));
    return 0;
}

PS：它不是递归的，但你可以修改它来实现。

Answer 15

我意识到，当您拥有大量数据时，不使用内存处理比“管道”命令要快。所以我将结果保存到一个文件中，然后进行分析：

ls -1 /path/to/dir > count.txt && wc-l count.txt

Answer 16

文件数最多的前 10 个目录。

dir=/ ; for i in $(ls -1 ${dir} | sort -n) ; { echo "$(find ${dir}${i} \
    -type f | wc -l) => $i,"; } | sort -nr | head -10

Answer 17

我更喜欢以下命令来跟踪目录中文件数量的变化。

watch -d -n 0.01 'ls | wc -l'

该命令将保持一个窗口打开，以 0.1 秒的刷新率跟踪目录中的文件数。