java - NodeJS 和 Java 的比较

Question

所以这是我的 Node js http 服务器在一个程序文件中，重要的是我没有在 2 个单独的进程中运行低于 2 个服务器。它们在同一进程中运行。

var today = require('./today');
var http = require('http');

var server1 = http.createServer(function(request, response) {
    var now = Date.now();
    var body = "The day of the week is " + today() + " " + now;
    response.writeHead(200, {
        'Content-Length': body.length,
        'Content-Type': 'text/plain'
    });
    response.end(body);
});

server1.listen(3000);


var server2 = http.createServer(function(request, response) {
    var body = "The day of the week is " + today();
    var count = 0;
    while (true) {
        count++;
        if(count == 10000){
            console.log('server2');
            count = 0;
        }
    }   
    response.writeHead(200, {
        'Content-Length': body.length,
        'Content-Type': 'text/plain'
    });
    response.end(body);
});

server2.listen(3002);

运行这个 Node js 程序后，我向 server1 发送了请求，它起作用了，即我得到了良好的响应。 (200)

然后我向 server2 发送了请求，它进入了无限循环，第二个请求显然挂起了。

当第二个请求挂起时，我在端口 3000 向 server1 发送第三个请求，server1 也挂起，所以这意味着Nodejs 不支持并发请求处理，即当回调处理程序处理特定请求时，没有其他请求即使我的机器是英特尔 i7 多核也可以处理...server2 中的无限循环应该只阻止其中一个核心，剩余的核心应该已经处理了 server1 上的后续请求。

#

下面是部署在glassfish中的java web服务，我将其开发为无状态EJB，以便ejb容器可以创建多个实例该 EJB 的一部分并同时处理该 Web 服务上的多个请求

@WebService(serviceName = "NewWebService")
@Stateless()
public class NewWebService {

    @WebMethod(operationName = "hello")
    public String hello(@WebParam(name = "name") String txt) {
        if(txt.equals("infinite")){
            int i = 0;
            while(true){
                i++;
                if(i>10000){
                    try{
                        Thread.sleep(2000);
                        i=0;
                    }catch(Exception e){

                    }
                }
            }
        }
        return "Hello " + txt + " !" + (new Date());
    }
}

当我在 glassfish 中部署上述 Web 服务并发送以“无限”作为输入的请求时，该请求挂起，但从另一个浏览器窗口我向同一 Web 服务发送了另一个以“Aziz”作为输入的请求，它同时返回了良好的结果当带有“无限”输入的窗口挂起时......但是当我评论 Thread.sleep(2000); 时在上面，两个请求都挂起，因此这意味着 JAVA 也不支持并发请求。

结论:java和node js的行为方式至少对于我创建的Web服务器来说是相同的，不管nodejs有一个回调的概念，它预计是一些神奇的东西......所以我的问题是为什么我们特别将 NodeJS 调用为单线程，在这个特定问题中，java 的行为方式相同。

注意:我不是在谈论您可以使用 crypto.pbkdf2sync crypto.pbkdf2 等异步函数进行的 NodeJS 异步调用。###################### ########

在@minus第一次更新后更新:非常感谢@minus，你说:“如果你的响应时间 99% 是由于 IO，那么 Nodejs 就可以正常工作，甚至比 java 的多线程环境更好。”

所以我改变了我的 Node 代码，我改变了无限调用来读取文件，这主要是基于IO的操作，仍然是server2阻塞了server1。如果我们将 Node 的行为与 java 的行为进行比较，那么 java 正在并发处理，因为 Node 在长时间运行的回调上被阻塞......该回调是否主要执行 IO 并不重要。以下是我更改的 Node 代码:

var http = require('http');

var server1 = http.createServer(function(request, response) {
    var now = Date.now();
    var body = "Time " + now;
    response.writeHead(200, {
        'Content-Length': body.length,
        'Content-Type': 'text/plain'
    });
    response.end(body);
});

server1.listen(3000);

var fs = require('fs');

var server2 = http.createServer(function(request, response) {
    while (true) {
        fs.readFile('stuff.txt', 'utf8', function(err, contents) {
            if(err){
               console.log(err);
            }else{
               console.log(contents);
            }
        }); 

        var contents = fs.readFileSync('stuff.txt', 'utf8');
        console.log(contents);
    }

    var now = Date.now();
    var body = "Time " + now;

    response.writeHead(200, {
        'Content-Length': body.length,
        'Content-Type': 'text/plain'
    });
    response.end(body);
});

server2.listen(3002);

Answer 1

我无法复制您的精确测试，但我可以使用 Java 中的最少配置进行类似的测试。

我使用maven来管理依赖项。

这是运行该示例的最小 pom。

<project xmlns="http://maven.apache.org/POM/4.0.0"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <groupId>it.minus</groupId>
    <artifactId>thread.demo.ws</artifactId>
    <version>0.0.1</version>
    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <maven.compiler.source>1.8</maven.compiler.source>
        <maven.compiler.target>1.8</maven.compiler.target>
        <jersey.version>2.29</jersey.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.glassfish.jersey.containers</groupId>
            <artifactId>jersey-container-grizzly2-http</artifactId>
            <version>${jersey.version}</version>
        </dependency>
        <dependency>
            <groupId>org.glassfish.jersey.inject</groupId>
            <artifactId>jersey-hk2</artifactId>
            <version>${jersey.version}</version>
        </dependency>
    </dependencies>
</project>

这是运行服务器的类:

package thread.demo.ws;

import java.io.IOException;
import java.net.URI;
import java.net.URISyntaxException;

import org.glassfish.grizzly.http.server.HttpServer;
import org.glassfish.jersey.grizzly2.httpserver.GrizzlyHttpServerFactory;
import org.glassfish.jersey.server.ResourceConfig;

public class Run {

    public static void main(String[] args) throws URISyntaxException {
        String BASE_URI = "http://0.0.0.0:3000/ws/";
        final ResourceConfig rc = new ResourceConfig().packages("thread.demo.ws");
        HttpServer server = GrizzlyHttpServerFactory.createHttpServer(new URI(BASE_URI), rc, false);
        try {
            server.start();
            System.in.read();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            server.shutdownNow();
            System.exit(0);
        }
    }
}

这是资源:

package thread.demo.ws;

import javax.ws.rs.GET;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.MediaType;

@Path("echo")
public class Echo {

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String get(@QueryParam("msg") String echoMsg) {
        if("LOCK".equalsIgnoreCase(echoMsg)) {
            while(true) {
            }
        }
        String reply = echoMsg == null ? "PING" : echoMsg;
        return " - " + reply + " - ";
    }
}

将触发服务的请求是:

http://localhost:3000/ws/echo?msg=hello

将永远锁定踏板的请求是:

http://localhost:3000/ws/echo?msg=LOCK

你可以测试一下，你会发现即使一个(或多个)回复请求的线程陷入无限循环，Java 也会继续处理请求。

最终你会锁定太多线程，系统将不再响应。

Java 是多线程的，因此您可以同时处理多个请求。

您的测试未提供正确结果的原因可能取决于多种原因，最合理的原因是，通过在线程中引起无限循环，您可能会阻止应用程序服务器的正常关闭，也可能会阻止正确的关闭重新部署您的应用程序。

Java 和 Node 有 2 种不同的方法来处理并发请求，Node 选择使用多个进程，每个进程管理非阻塞 IO 处理，而 Java(主要)使用运行多个线程的单个进程，具体取决于许多不同的因素中，一个因素可以比另一个因素表现得更好。

还有许多用java编写的应用程序服务器使用NIO(非阻塞IO)来减少使用的线程数量，因此在java中也可以使用相同的Node范例。

评论后更新

您通过阻塞 server1 来滥用 Nodejs。

这是一个有用的实验，可以了解代码任何部分的阻塞有多严重，但你真的不应该在 js 中阻塞。

您的服务器将或多或少地实现为:

function(request, response) {
    request.json()
        .then(data=>callService(data))
        .catch(err=> sendError(err,response))
        .then(someEntity => buildResponseWithEntity(someEntity,response ) )
        .catch(e => logError(e));
}

函数的主体将立即返回，而进程的每个步骤(.then 和 .catch)最终都会被处理，每个步骤也不会阻塞等待任何 IO。

如果你的响应时间99%是由于IO，nodejs就可以正常工作，甚至比java的多线程环境更好。

要详细解释这一点需要太多时间。