使用Java、Rust、Go、JavaScript (NodeJS)、TypeScript 等流行语言构建并发 Web 服务器并对其进行基准测试(Deno) 和 Kotlin 来比较这些语言/平台之间的并发性及其性能。
Rust 中的并发
高效和内存安全的并发是 Rust 的主要目标之一，这些不仅仅是简单的词，该语言为并发编程提供了强大的功能，当与同类最佳的内存安全模型相结合时，使其成为并发用例的绝佳选择。
Rust 提供构建块来创建和管理操作系统线程作为标准库的一部分，它还提供使用通道的消息传递并发（类似于 Go）和使用互斥体和智能指针的共享状态并发所需的实现。Rust 的类型系统和所有权模型有助于避免常见的并发问题，如数据竞争、锁等。
最新版本的 Rust 提供了使用async/.await语法进行 异步 编程所需的构建块和语言功能。但请记住，使用异步编程模型会增加整体复杂性，而且生态系统仍在不断发展。虽然 Rust 提供了所需的语言功能，但标准库不提供任何所需的实现，因此您必须使用外部 crateFutures才能有效地使用异步编程模型。
带有 Tokio 的异步多线程并发网络服务器：这是另一个使用Tokio的异步多线程网络服务器版本，由Remco Bloemen贡献。为简洁起见，我省略了导入语句。您可以在GitHub 上找到完整示例。
#[tokio::main()] // 默认情况下，Tokio 使用一个线程池大小适合 CPU 数量
异步 fn main() {
让 listener = TcpListener::bind( "127.0.0.1:8080" ).await.unwrap(); // 绑定监听器
let mut count = 0; // 用于引入延迟的计数
// 监听传入的连接。
环形 {
计数 = 计数 + 1；
让 (socket, _) = listener.accept().await.unwrap();
// 在新的 tokio 线程中异步
生成每个连接tokio::spawn(async move { handle_connection(socket, Box:: new (count)).await });
}
}
异步 fn handle_connection（mut 流：TcpStream，计数：Box<i64>）{
// 从流中读取前 1024 个字节的数据
让 mut 缓冲区 = [0; [1024];
stream.read(&mut buffer).await.unwrap();
// 每 10 个请求添加 2 秒延迟if (*count % 10) == 0 {
println!( "添加延迟。计数：{}" , count);
sleep(Duration::from_secs(2)).await;
}
让标题 = "
HTTP/1.0 200 正常
连接：保持连接
内容长度：174
内容类型：文本/html；字符集=utf-8
";
让内容 = read_to_string( "hello.html" ).await.unwrap();
let response = format!( "{}\r\n\r\n{}" , 标题, 内容);
stream.write_all(response.as_bytes()).await.unwrap(); // 写响应
}
|
Threadpool除了异步调用之外，也有来自线程池的相同瓶颈，因此我们将线程池设置为 100 以匹配最大并发请求。
让我们使用 ApacheBench 运行一个基准测试。我们将发出 10000 个请求和 100 个并发请求。
ab -c 100 -n 10000
这是 ApacheBench，版本 2.3 <$Revision: 1879490 $>
...
文件路径：/
文件长度：176 字节
并发级别：100
拍摄时间为测试：20.569秒
完成请求：10000
失败的请求：0
总传输量：3030000 字节
传输的 HTML：1760000 字节
每秒请求数：486.17 [#/sec]（平均值）
每个请求的时间：205.688 [ms]（平均值）
每个请求的时间：2.057 [ms]（平均，跨所有并发请求）
传输速率：143.86 [Kbytes/sec] 接收
连接时间（毫秒）
最小平均值[+/-sd] 中值最大值
连接：0 1 2.4 0 22
处理：0 202 600.3 1 2013
等待：0 202 600.3 1 2012
总计：0 203 600.3 2 2029
特定时间内服务的请求百分比（毫秒）
50% 2
66% 3
75% 5
80% 7
90% 2000
95% 2003
98% 2006
99% 2008
100% 2029（最长请求）
|
Java 中的并发
这个例子更接近Rust语言的异步例子，为了简洁我省略了 import 语句。您可以在GitHub 上找到完整示例。请注意，我们在java.nio.channels.AsynchronousServerSocketChannel这里使用并且没有外部依赖项。
公共 类JavaAsyncHTTPServer {
public static void main(String[] args) 抛出异常 {
new JavaAsyncHTTPServer().start();
Thread.currentThread().join(); // 永远等待
}
private void start() throws IOException {
// 我们不应该在这里使用 try with resource 因为它会杀死流var server = AsynchronousServerSocketChannel.open();
server.bind( new InetSocketAddress( "127.0.0.1" , 8080), 100); // 绑定监听器
server.setOption(StandardSocketOptions.SO_REUSEADDR, true );
System.out.println( "服务器正在监听8080端口" );
最终 int [] 计数 = {0}；// 用于引入延迟的计数
// 监听所有传入请求
server.accept( null , new CompletionHandler<>() {
@覆盖
公共 无效完成（最终的AsynchronousSocketChannel结果，最终的对象附件）{
如果（server.isOpen（））{
server.accept( null , this );
}
计数[0]++；
handleAcceptConnection(result, count[0]);
}
@覆盖
public void failed( final Throwable exc, final Object attach ) {
if (server.isOpen()) {
server.accept( null , this );
System.out.println( "连接处理程序错误：" + exc);
}
}
});
}
private void handleAcceptConnection( final AsynchronousSocketChannel ch, final int count) {
var file = new File( "hello.html" );
try ( var fileIn = new FileInputStream(file)) {
// 每 10 个请求添加 2 秒延迟if (count % 10 == 0) {
System.out.println( "添加延迟。计数：" + count);
线程睡眠（2000）；
}
if (ch != null && ch.isOpen()) {
// 从流中读取前 1024 个字节的数据final ByteBuffer buffer = ByteBuffer.allocate(1024);
// 完全读取请求以避免连接重置错误
ch.read(buffer).get();
// 读取 HTML 文件var fileLength = ( int ) file.length();
var fileData =新字节[文件长度];
fileIn.read (fileData);
// 发送 HTTP 标头var message = ( "HTTP/1.1 200 OK\n" +
"Connection: keep-alive\n" +
"Content-length: " + fileLength + "\n" +
"Content-Type: text/ html; charset=utf-8\r\n\r\n" +
new String(fileData, StandardCharsets.UTF_8)
).getBytes();
// 写入输出流
ch.write(ByteBuffer.wrap(message)).get();
缓冲区清除（）；
ch.close();
}
} catch (IOException | InterruptedException | ExecutionException e) {
System.out.println( "连接处理程序错误：" + e);
}
}
}
|
我们将异步侦听器绑定到端口 8080 并侦听所有传入请求。每个请求都在由 AsynchronousServerSocketChannel提供的新任务中处理。我们在这里没有使用任何线程池，所有传入的请求都是异步处理的，因此我们没有最大连接数的瓶颈。
让我们使用 ApacheBench 运行一个基准测试。我们将发出 10000 个请求和 100 个并发请求。
ab -c 100 -n 10000
这是 ApacheBench，版本 2.3 <$Revision: 1879490 $>
...
文件路径：/
文件长度：176 字节
并发级别：100
拍摄时间为测试：20.243秒
完成请求：10000
失败的请求：0
总传输量：2770000 字节
传输的 HTML：1760000 字节
每秒请求数：494.00 [#/sec]（平均值）
每个请求的时间：202.431 [ms]（平均值）
每个请求的时间：2.024 [ms]（平均，跨所有并发请求）
传输速率：133.63 [Kbytes/sec] 接收
连接时间（毫秒）
最小平均值[+/-sd] 中值最大值
连接：0 0 0.6 0 5
处理：0 201 600.0 0 2026
等待：0 201 600.0 0 2026
总计：0 202 600.0 0 2026
特定时间内服务的请求百分比（毫秒）
50% 0
66% 1
75% 3
80% 4
90% 2000
95% 2001
98% 2002
99% 2003
100% 2026（最长请求）
|
Go 中的并发
不要通过共享内存进行通信；相反，通过通信共享内存。Go 支持并发作为一等公民，其goroutines. Go 将协程的概念提升到一个全新的水平，使其更简单，并且成为在 Go 中执行几乎任何事情的首选方式。语义和语法非常简单，即使是 Go 新手也能从一开始就goroutines轻松上手。所有这一切都没有牺牲性能。
为简洁起见，我省略了导入语句。您可以在GitHub 上找到完整示例。在这种情况下，我们也没有使用任何外部依赖项，并且http是 Go 标准库的一部分。
func main() {
var count = 0
// 设置路由器
http.HandleFunc( "/" , func(w http.ResponseWriter, r *http.Request) {
延迟 r.Body.Close()
计数++
句柄连接（w，计数）
})
// 设置监听端口
err := http.ListenAndServe( ":8080" , nil)
if err != nil {
log.Fatal( "ListenAndServe:" , 错误)
}
}
func handleConnection(w http.ResponseWriter, count int ) {
// 每 10 个请求添加 2 秒延迟if (count % 10) == 0 {
println( "添加延迟。计数：" , count)
time.Sleep(2 * time.Second)
}
html, _ := ioutil.ReadFile( "hello.html" ) // 读取 html 文件
w.Header().Add( "Connection" , "keep-alive" )
w.WriteHeader(200) // 200 OK
fmt.Fprintf(w, string(html)) // 向客户端发送数据
}
|
如您所见，我们创建了一个绑定到端口 8080 的 HTTP 服务器并侦听所有传入请求。我们分配一个回调函数来处理内部调用handleConnection方法的每个请求。
让我们使用 ApacheBench 运行一个基准测试。我们将发出 10000 个请求和 100 个并发请求。
ab -c 100 -n 10000
这是 ApacheBench，版本 2.3 <$Revision: 1879490 $>
...
文件路径：/
文件长度：174 字节
并发级别：100
拍摄时间为测试：20.232秒
完成请求：10000
失败的请求：0
总传输量：2910000 字节
传输的 HTML：1740000 字节
每秒请求数：494.27 [#/sec]（平均值）
每个请求的时间：202.319 [ms]（平均值）
每个请求的时间：2.023 [ms]（平均，跨所有并发请求）
传输速率：140.46 [Kbytes/sec] 接收
连接时间（毫秒）
最小平均值[+/-sd] 中值最大值
连接：0 1 0.9 0 6
处理：0 201 600.0 1 2013
等待：0 201 600.0 0 2013
总计：0 202 600.0 1 2018
警告：中位数和平均为初始连接时是不正常的偏差范围内
这些结果可能并不那么可靠。
特定时间内服务的请求百分比（毫秒）
50% 1
66% 1
75% 2
80% 3
90% 2000
95% 2001
98% 2002
99% 2003
100% 2018（最长请求）
|
JavaScript 和 NodeJS 中的并发
JavaScript 是单线程的，因此实现多线程的唯一方法是启动 JS 引擎的多个实例。但是，您如何在这些实例之间进行通信？这就是Web Workers 的用武之地。
Web Workers 使在与 Web 应用程序的主执行线程分离的后台线程中运行脚本操作成为可能
在 Web Worker 的帮助下，可以将繁重的计算卸载到单独的线程，从而释放主线程。这些工作线程和主线程使用事件进行通信，一个工作线程可以产生其他工作线程。
现在，当谈到 NodeJS 时，几乎没有方法可以产生额外的线程和进程。有经典child_process模块，更现代的worker_threads模块，与 Web Worker 非常相似，以及cluster用于创建 NodeJS 实例集群的模块。
无论是 web worker 还是 worker 线程，它们都不像其他语言中的多线程实现那样灵活或简单，并且有很多限制，因此它们大多只在有 CPU 密集型任务或后台任务需要执行以供其他用途时使用使用异步处理的并发情况就足够了。
JavaScript 不提供对 OS 线程或绿色线程的访问，同样适用于 NodeJS 但是工作线程和集群很接近，因此高级多线程是不可行的。消息传递并发是可能的，由 JS 事件循环本身使用，可用于 JS 中的 Worker 和标准并发模型。在标准并发模型和使用数组缓冲区的工作线程中，共享状态并发是可能的。
我们使用cluster模块来分叉主线程和工作线程，每个 CPU 线程一个工作线程。我们仍然在http这里使用模块和回调。您可以在GitHub 上找到完整示例。在这种情况下，我们也没有使用任何外部依赖。
const http = require("http");
const fs = require("fs").promises;
const cluster = require("cluster");
const numCPUs = require("os").cpus().length;
let count = 0;
// set router
const server = http.createServer((req, res) => {
count++;
requestListener(req, res, count);
});
const host = "localhost";
const port = 8080;
if (cluster.isMaster) {
console.log(`Master ${process.pid} is running`);
// Fork workers.
for (let i = 0; i < numCPUs; i++) {
cluster.fork();
}
cluster.on("exit", (worker, code, signal) => {
console.log(`worker ${worker.process.pid} died`);
});
} else {
// set listen port, TCP connection is shared by all workers
server.listen(port, host, () => {
console.log(`Worker ${process.pid}: Server is running on {host}:${port}`);
});
}
const requestListener = async function (req, res, count) {
// add 2 second delay to every 10th request
if (count % 10 === 0) {
console.log("Adding delay. Count: ", count);
await sleep(2000);
}
const contents = await fs.readFile(__dirname + "/hello.html"); // read html file
res.setHeader("Connection", "keep-alive");
res.writeHead(200); // 200 OK
res.end(contents); // send data to client side
};
// sleep function since NodeJS doesn't provide one
function sleep(ms) {
return new Promise((resolve) => {
setTimeout(resolve, ms);
});
}
|
集群模块分为 master 和 worker。我们分配一个回调函数来处理内部调用该requestListener方法的每个请求。
让我们使用 ApacheBench 运行一个基准测试。我们将发出 10000 个请求和 100 个并发请求。
ab -c 100 -n 10000
This is ApacheBench, Version 2.3 <$Revision: 1879490 $>
...
Server Software:
Server Hostname: 127.0.0.1
Server Port: 8080
Document Path: /
Document Length: 174 bytes
Concurrency Level: 100
Time taken for tests: 21.075 seconds
Complete requests: 10000
Failed requests: 0
Total transferred: 2540000 bytes
HTML transferred: 1740000 bytes
Requests per second: 474.50 [#/sec] (mean)
Time per request: 210.747 [ms] (mean)
Time per request: 2.107 [ms] (mean, across all concurrent requests)
Transfer rate: 117.70 [Kbytes/sec] received
Connection Times (ms)
min mean[+/-sd] median max
Connect: 0 0 0.8 0 11
Processing: 0 206 600.1 4 2047
Waiting: 0 205 600.1 3 2045
Total: 1 206 600.1 4 2047
Percentage of the requests served within a certain time (ms)
50% 4
66% 8
75% 11
80% 14
90% 88
95% 2005
98% 2012
99% 2016
100% 2047 (longest request)
|
Deno 中的并发
TypeScript 中的并发性与 JavaScript 中的完全相同，因为 TypeScript 是 JavaScript 的严格超集。
因此，如果您将 TypeScript 与 NodeJS 一起使用，它与在 NodeJS 上使用 JavaScript 完全相同，因为 NodeJS 不会在本地运行 TypeScript，我们必须将其转换为 JavaScript，因此让我们专注于 Deno 上的 TypeScript，因为我们已经涵盖了 NodeJS。
与 NodeJS 不同，Deno 可以在本地运行 TypeScript，它会在幕后转换为 JS。正如我们在 NodeJS 中看到的，Deno 还专注于非阻塞 IO，旨在改进/修复 NodeJS 中的问题。这意味着你也可以在 Deno 上使用 NodeJS 和 JavaScript 完成所有可以做的事情，有时使用更好的 API 和更少的代码。就像在 JS 中一样，您依靠事件循环、回调、承诺和Async/Await来实现 TypeScript 中的并发。
Deno API 默认是异步的，并且推荐经常使用 async/await 。
Deno 中的默认并发是使用回调、Promise 或 async/await 的异步编程模型。
就像在 JavaScript 中一样，也可以在 Deno 上使用 TypeScript 进行某种程度的多线程并发和并行化，并且由于 Deno 是基于 Rust 构建的，因此未来并发性能可能会比NodeJS 上的更好。
这个例子更接近Rust 异步例子。您可以在此处在GitHub 上找到完整示例。在这种情况下，我们仅使用标准 Deno 模块。
import { serve, ServerRequest } from "#34;;
let count = 0;
// set listen port
const server = serve({ hostname: "0.0.0.0", port: 8080 });
console.log(`HTTP webserver running at: `);
// listen to all incoming requests
for await (const request of server) handleRequest(request);
async function handleRequest(request: ServerRequest) {
count++;
// add 2 second delay to every 10th request
if (count % 10 === 0) {
console.log("Adding delay. Count: ", count);
await sleep(2000);
}
// read html file
const body = await Deno.readTextFile("./hello.html");
const res = {
status: 200,
body,
headers: new Headers(),
};
res.headers.set("Connection", "keep-alive");
request.respond(res); // send data to client side
}
// sleep function since NodeJS doesn't provide one
function sleep(ms: number) {
return new Promise((resolve) => {
setTimeout(resolve, ms);
});
}
|
我们创建了一个 HTTP 服务器并将其绑定到端口 8080 并在 for await 循环中侦听所有传入请求。每个请求都在内部使用async/await函数处理。
让我们使用 ApacheBench 运行一个基准测试。我们将发出 10000 个请求和 100 个并发请求。
ab -k -c 100 -n 10000
This is ApacheBench, Version 2.3 <$Revision: 1879490 $>
...
Server Software:
Server Hostname: 127.0.0.1
Server Port: 8080
Document Path: /
Document Length: 174 bytes
Concurrency Level: 100
Time taken for tests: 21.160 seconds
Complete requests: 10000
Failed requests: 0
Keep-Alive requests: 10000
Total transferred: 2380000 bytes
HTML transferred: 1740000 bytes
Requests per second: 472.59 [#/sec] (mean)
Time per request: 211.600 [ms] (mean)
每个请求的时间：2.116 [ms]（平均，跨所有并发请求）
传输速率：109.84 [Kbytes/sec] 接收
连接时间（毫秒）
最小平均值[+/-sd] 中值最大值
连接：0 0 0.7 0 11
处理：0 207 600.7 5 2250
等待：0 207 600.7 5 2250
总计：0 207 600.7 5 2254
特定时间内服务的请求百分比（毫秒）
50% 5
66% 8
75% 11
80% 13
90% 2001
95% 2006
98% 2012
99% 2017
100% 2254（最长请求）
|
