如何让Node.js脚本复用已有应用实例并后台运行？

问题背景 #

现有一个用立即执行函数封装的计数器应用脚本index.js，代码如下：

// ####################################################
// Define app
// ####################################################

const app = (() => {
    let counterInterval;
    let counter = 0;

    function startCounter() {
        counterInterval = setInterval(() => counter++, 1000);
    }

    function pauseCounter() {
        clearInterval(counterInterval);
    }

    function showCounter() {
        console.log(counter);
    }

    return {
        startCounter,
        pauseCounter,
        showCounter,
    }
})();

// ####################################################
// Run selected app method
// ####################################################

const argvs = process.argv.slice(2);
const [command, ...args] = argvs;

if (command === 'startCounter') {
    app.startCounter();
}

if (command === 'pauseCounter') {
    app.pauseCounter();
}

if (command === 'showCounter') {
    app.showCounter();
}

当前执行node ./index.js startCounter会占用终端，且每次执行命令都会启动新Node.js进程，导致计数器状态无法在多次命令间共享。需要实现：

1. 启动计数器后进程后台运行，不占用终端；
2. 后续执行showCounter/pauseCounter时，操作的是同一个应用实例的状态。

核心原理 #

Node.js中每个node命令都是独立的V8进程，进程间内存完全隔离，没有原生的跨进程共享内存实例机制。必须通过进程间通信（IPC）或外部状态持久化来实现需求。

解决方案 #

方案1：原生Node.js实现（IPC通信+后台进程） #

通过Unix域套接字（Windows用命名管道）实现后台服务与客户端命令的通信，无需第三方依赖。

改造后的index.js代码

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

// 定义套接字文件路径（Unix系统用此，Windows可替换为命名管道）
const socketPath = path.join(__dirname, 'counter.sock');

// 应用核心状态与方法（保留原有逻辑）
let counterInterval;
let counter = 0;

function startCounter() {
    if (!counterInterval) {
        counterInterval = setInterval(() => counter++, 1000);
    }
}

function pauseCounter() {
    clearInterval(counterInterval);
    counterInterval = null;
}

function showCounter() {
    return counter.toString();
}

// 命令处理逻辑
function handleCommand(command) {
    switch(command.trim()) {
        case 'startCounter':
            startCounter();
            return '计数器已启动';
        case 'pauseCounter':
            pauseCounter();
            return '计数器已暂停';
        case 'showCounter':
            return `当前计数：${showCounter()}`;
        default:
            return '未知命令，请使用 startCounter/pauseCounter/showCounter';
    }
}

const argvs = process.argv.slice(2);
const [command] = argvs;

// 模式判断：启动后台服务 或 发送命令
if (!command || command === 'start') {
    // 清理旧的套接字文件（避免端口占用）
    try {
        fs.unlinkSync(socketPath);
    } catch (err) {}

    // 创建TCP服务器（基于Unix域套接字）
    const server = net.createServer((socket) => {
        socket.on('data', (data) => {
            const result = handleCommand(data.toString());
            socket.write(result + '\n');
            socket.end();
        });
    });

    server.listen(socketPath, () => {
        console.log(`计数器服务已启动，套接字路径：${socketPath}`);
        // 脱离终端控制，实现后台运行（Unix系统生效）
        if (process.platform !== 'win32') {
            process.disconnect();
            process.stdin.unref();
            process.stdout.unref();
            process.stderr.unref();
        }
    });

    // 进程退出时清理套接字文件
    process.on('exit', () => {
        try {
            fs.unlinkSync(socketPath);
        } catch (err) {}
    });
} else {
    // 作为客户端发送命令到后台服务
    const client = net.connect(socketPath);
    client.write(command);
    client.on('data', (data) => {
        console.log(data.toString().trim());
        client.end();
        process.exit(0);
    });
    client.on('error', () => {
        console.error('错误：计数器服务未启动，请先执行 node index.js start');
        process.exit(1);
    });
}

使用步骤

1. 启动后台服务
   • Unix/Linux/macOS：nohup node index.js start > /dev/null 2>&1 &（关闭终端也能持续运行）
   • Windows：start /B node index.js start（后台运行，需保留终端窗口或用其他工具）
2. 操作计数器
   • 查看计数：node index.js showCounter
   • 暂停计数：node index.js pauseCounter
   • 重启计数：node index.js startCounter
3. 停止服务：直接杀死对应Node.js进程即可，或添加stop命令逻辑。

方案2：使用PM2进程管理工具（简便高效） #

如果不想手动实现IPC，可借助PM2（常用Node.js进程管理器），配合文件持久化状态，快速实现需求。

步骤1：安装PM2

npm install -g pm2

步骤2：改造应用（状态持久化到文件）

修改原index.js，将计数器状态保存到本地文件，确保进程重启或跨命令访问时状态不丢失：

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

// 状态文件路径
const stateFile = path.join(__dirname, 'counter-state.json');

// 加载/保存状态工具函数
function loadState() {
    try {
        const data = fs.readFileSync(stateFile, 'utf8');
        return JSON.parse(data);
    } catch (err) {
        return { counter: 0, intervalId: null };
    }
}

function saveState(state) {
    fs.writeFileSync(stateFile, JSON.stringify(state));
}

let state = loadState();

// 核心方法改造
function startCounter() {
    if (!state.intervalId) {
        state.intervalId = setInterval(() => {
            state.counter++;
            saveState(state);
        }, 1000);
        saveState(state);
    }
}

function pauseCounter() {
    clearInterval(state.intervalId);
    state.intervalId = null;
    saveState(state);
}

function showCounter() {
    state = loadState(); // 读取最新状态
    console.log(state.counter);
}

// 命令处理
const argvs = process.argv.slice(2);
const [command] = argvs;

switch(command) {
    case 'startCounter':
        startCounter();
        console.log('计数器已启动');
        break;
    case 'pauseCounter':
        pauseCounter();
        console.log('计数器已暂停');
        break;
    case 'showCounter':
        showCounter();
        break;
    default:
        console.log('未知命令，请使用 startCounter/pauseCounter/showCounter');
}

步骤3：后台启动服务

pm2 start index.js --name counter-app -- startCounter

步骤4：操作计数器

• 查看计数：pm2 exec counter-app -- showCounter
• 暂停计数：pm2 exec counter-app -- pauseCounter
• 查看进程状态：pm2 status
• 停止进程：pm2 stop counter-app
• 重启进程：pm2 restart counter-app

总结 #

• 原生Node.js无跨进程共享内存实例的机制，必须通过IPC或外部持久化实现状态共享；
• 方案1适合需要自定义通信逻辑、无依赖的场景；
• 方案2使用PM2更简便，适合快速开发，同时PM2还提供进程监控、自动重启等额外功能。

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