TL;DR

What is the best way to forcibly keep a Node.js process running, ie, keep its event loop from running empty and hence keeping the process from terminating? The best solution I could come up with was this:

setInterval(() => {}, Number.POSITIVE_INFINITY);

Is there a better way to do it?

Long version of the question

I have a Node.js script using Edge.js to register a callback function so that it can be called from inside a DLL in .NET. This function will be called 1 time per second, sending a simple sequence number that should be printed to the console.

The Edge.js part is fine, everything is working. My only problem is that my Node.js process executes its script and after that it runs out of events to process. With its event loop empty, it just terminates, ignoring the fact that it should've kept running to be able to receive callbacks from the DLL.

My Node.js script:

var
    edge = require('edge');

var foo = edge.func({
    assemblyFile: 'cs.dll',
    typeName: 'cs.MyClass',
    methodName: 'Foo'
});

// The callback function that will be called from C# code:
function callback(sequence) {
    console.info('Sequence:', sequence);
}

// Register for a callback:
foo({ callback: callback }, true);

// My hack to keep the process alive:
setInterval(function() {}, 60000);

My C# code (the DLL):

public class MyClass
{
    Func<object, Task<object>> Callback;

    void Bar()
    {
        int sequence = 1;

        while (true)
        {
            Callback(sequence++);
            Thread.Sleep(1000);
        }
    }

    public async Task<object> Foo(dynamic input)
    {
        // Receives the callback function that will be used:
        Callback = (Func<object, Task<object>>)input.callback;

        // Starts a new thread that will call back periodically:
        (new Thread(Bar)).Start();

        return new object { };
    }
}

The only solution I could come up with was to register a timer with a long interval to call an empty function just to keep the scheduler busy and avoid getting the event loop empty so that the process keeps running forever.

Is there any way to do this better than I did? Ie, keep the process running without having to use this kind of "hack"?

---

使用“旧”Streams模式来监听永远不会来的标准输入：

// Start reading from stdin so we don't exit.
process.stdin.resume();

---

Although it looks like there's no right answer to this question, so far we have 3 possible hacks and I honestly think my approach is the less intrusive one:

setInterval(() => {}, Number.POSITIVE_INFINITY);

This will set an interval that will never fire. Interesting to note that setTimeout() doesn't work the same and will not schedule at all if given Number.POSITIVE_INFINITY as its timeout parameter.

For reference, here are the other two answers given so far:

Joe's:

require('net').createServer().listen();

Will create a "bogus listener", as he called it. A minor downside is that we'd allocate a port just for that.

Jacob's:

process.stdin.resume();

Or the equivalent:

process.stdin.on("data", () => {});

Puts stdin into "old" mode, a deprecated feature that is still present in Node.js for compatibility with scripts written prior to Node.js v0.10 (reference).

链接地址: http://www.djcxy.com/p/52694.html

上一篇: 节点js中的进程退出事件的目的是什么？

下一篇: 如何强制保持Node.js进程终止？