文件描述符

文件描述符基础概念

文件描述符（File Descriptor）是操作系统级的概念，它是一个非负整数，用于标识打开的文件或I/O资源。在Unix-like系统中，一切皆文件的思想使得文件描述符成为访问各种I/O设备的核心机制。

const fs = require('fs');

// 获取文件描述符
fs.open('example.txt', 'r', (err, fd) => {
  if (err) throw err;
  console.log(`文件描述符是: ${fd}`);
  
  // 记得关闭文件描述符
  fs.close(fd, (err) => {
    if (err) throw err;
  });
});

Node.js中的文件描述符处理

Node.js通过fs模块提供了文件系统操作接口，其中多个API都涉及文件描述符的使用。与直接使用文件路径不同，通过文件描述符操作文件可以避免重复的路径解析和权限检查。

const fs = require('fs');
const fsPromises = fs.promises;

// 使用Promise风格的API
async function readWithFd() {
  let fd;
  try {
    fd = await fsPromises.open('data.txt', 'r');
    const buffer = Buffer.alloc(1024);
    const { bytesRead } = await fd.read(buffer, 0, buffer.length, 0);
    console.log(buffer.toString('utf8', 0, bytesRead));
  } finally {
    if (fd) await fd.close();
  }
}

标准流的文件描述符

在Unix系统中，有三个预定义的文件描述符：

• 0: 标准输入(stdin)
• 1: 标准输出(stdout)
• 2: 标准错误(stderr)

Node.js中可以通过process对象访问这些标准流：

process.stdin.on('data', (data) => {
  process.stdout.write(`你输入了: ${data}`);
  process.stderr.write(`日志: 收到输入 ${new Date().toISOString()}\n`);
});

文件描述符的高级用法

文件锁定

通过文件描述符可以实现文件锁定，防止多个进程同时修改文件：

const fs = require('fs');

fs.open('lockfile', 'wx', (err, fd) => {
  if (err) {
    if (err.code === 'EEXIST') {
      console.error('文件已被锁定');
      return;
    }
    throw err;
  }
  
  // 执行需要锁定的操作
  console.log('获得文件锁');
  
  // 操作完成后释放锁
  fs.close(fd, (err) => {
    if (err) throw err;
    console.log('释放文件锁');
  });
});

文件截断

通过文件描述符可以截断文件：

const fs = require('fs');

fs.open('largefile.txt', 'r+', (err, fd) => {
  if (err) throw err;
  
  // 将文件截断为100字节
  fs.ftruncate(fd, 100, (err) => {
    if (err) throw err;
    console.log('文件截断成功');
    fs.close(fd, () => {});
  });
});

文件描述符与流的关系

Node.js中的流(Stream)抽象底层也使用了文件描述符。例如创建可读流时：

const fs = require('fs');

// 底层会打开文件描述符
const readStream = fs.createReadStream('largefile.txt');

readStream.on('open', (fd) => {
  console.log(`文件描述符 ${fd} 已打开`);
});

readStream.on('close', () => {
  console.log('文件描述符已关闭');
});

文件描述符泄漏问题

未正确关闭文件描述符会导致资源泄漏，这在长时间运行的Node.js服务中尤为严重：

const fs = require('fs');

// 错误的做法 - 会导致描述符泄漏
function leakDescriptors() {
  for (let i = 0; i < 1000; i++) {
    fs.open('temp.txt', 'w', (err, fd) => {
      if (err) throw err;
      // 忘记关闭fd
    });
  }
}

// 正确的做法
function properDescriptorHandling() {
  let count = 0;
  
  function next() {
    if (count >= 1000) return;
    
    fs.open('temp.txt', 'w', (err, fd) => {
      if (err) throw err;
      
      // 处理文件...
      
      fs.close(fd, (err) => {
        if (err) throw err;
        count++;
        next();
      });
    });
  }
  
  next();
}

监测文件描述符使用情况

在开发过程中，可以使用以下方法监测文件描述符使用情况：

const fs = require('fs');
const os = require('os');

// 查看进程的文件描述符限制
console.log(`文件描述符限制: ${os.constants.UV_FS_O_FILEMAP}`);

// 在Linux系统下可以查看/proc/<pid>/fd目录
if (process.platform === 'linux') {
  const fdDir = `/proc/${process.pid}/fd`;
  fs.readdir(fdDir, (err, files) => {
    if (err) {
      console.error('无法读取fd目录:', err);
      return;
    }
    console.log(`当前打开的文件描述符数量: ${files.length}`);
  });
}

文件描述符与性能优化

合理管理文件描述符可以显著提升I/O性能：

const fs = require('fs');

// 低效的做法 - 每次操作都打开关闭文件
function inefficientWrite(data) {
  fs.open('data.log', 'a', (err, fd) => {
    if (err) throw err;
    
    fs.write(fd, data + '\n', (err) => {
      if (err) throw err;
      
      fs.close(fd, (err) => {
        if (err) throw err;
      });
    });
  });
}

// 高效的做法 - 保持文件描述符打开
let logFd;
fs.open('data.log', 'a', (err, fd) => {
  if (err) throw err;
  logFd = fd;
});

process.on('exit', () => {
  if (logFd !== undefined) {
    fs.closeSync(logFd);
  }
});

function efficientWrite(data) {
  if (logFd === undefined) {
    // 处理文件未打开的情况
    return inefficientWrite(data);
  }
  
  fs.write(logFd, data + '\n', (err) => {
    if (err) throw err;
  });
}

文件描述符与子进程

在创建子进程时，文件描述符的继承行为需要注意：

const { spawn } = require('child_process');
const fs = require('fs');

// 打开一个文件描述符
fs.open('input.txt', 'r', (err, fd) => {
  if (err) throw err;
  
  // 创建子进程，并传递文件描述符
  const child = spawn('node', ['child.js'], {
    stdio: ['inherit', 'inherit', 'inherit', fd]
  });
  
  child.on('exit', () => {
    fs.close(fd, () => {});
  });
});

异步与同步API的选择

Node.js提供了文件描述符操作的同步和异步版本：

const fs = require('fs');

// 同步方式
try {
  const fd = fs.openSync('sync.txt', 'w');
  fs.writeSync(fd, '同步写入数据');
  fs.closeSync(fd);
} catch (err) {
  console.error(err);
}

// 异步方式
fs.open('async.txt', 'w', (err, fd) => {
  if (err) return console.error(err);
  
  fs.write(fd, '异步写入数据', (err) => {
    if (err) return console.error(err);
    
    fs.close(fd, (err) => {
      if (err) console.error(err);
    });
  });
});

文件描述符与错误处理

正确处理文件描述符操作中的错误至关重要：

const fs = require('fs');

function safeFileOperation() {
  let fd;
  
  fs.open('important.data', 'r+', (openErr, fileDescriptor) => {
    if (openErr) {
      console.error('打开文件失败:', openErr);
      return;
    }
    fd = fileDescriptor;
    
    fs.write(fd, '新数据', (writeErr) => {
      if (writeErr) {
        console.error('写入文件失败:', writeErr);
        // 仍然需要尝试关闭文件描述符
        return fs.close(fd, () => {});
      }
      
      fs.close(fd, (closeErr) => {
        if (closeErr) {
          console.error('关闭文件失败:', closeErr);
        }
      });
    });
  });
}

文件描述符与网络套接字

在Node.js中，网络套接字也使用文件描述符抽象：

const net = require('net');
const fs = require('fs');

const server = net.createServer((socket) => {
  // 获取底层文件描述符
  const fd = socket._handle.fd;
  console.log(`新连接，套接字文件描述符: ${fd}`);
  
  socket.on('data', (data) => {
    // 使用文件描述符写入日志
    fs.write(fd, `[${new Date()}] ${data}\n`, (err) => {
      if (err) console.error('日志写入失败:', err);
    });
  });
});

server.listen(3000);