The impact of asynchronous and multithreaded query processing models on the performance of server-side web applications

Makarov Igor' Sergeevich ORCID: 0009-0004-8734-2667 PhD in Technical Science Head of the Department; Department of Applied Informatics (PI); Volga State University of Telecommunications and Informatics 23 Lva Tolstogo str., Samara region, 443010, Russia igor-psati@yandex.ru Larin Denis Vyacheslavovich ORCID: 0009-0000-1904-7210 Student; Department of Computer Science and Computer Engineering; Volga Region State University of Telecommunications and Informatics 23 Lva Tolstogo str., Samara, Samara region, 443010, Russia denlar1989@gmail.com Vorobeva Evgeniia Grigor'evna ORCID: 0009-0008-8225-7091 Student; Department of Computer Science and Computer Engineering; Volga Region State University of Telecommunications and Informatics 23 Lva Tolstogo str., Samara region, 443010, Russia vorobeva.g2004@gmail.com Emelin Daniil Pavlovich Student; Department of Computer Science and Computer Engineering; Volga Region State University of Telecommunications and Informatics 23 Lva Tolstogo str., Samara, Samara region, 443010, Russia demelin163@gmail.com

Kartashov Dmitry Aleksandrovich Student; Department of Computer Science and Computer Engineering; Volga Region State University of Telecommunications and Informatics 23 Lva Tolstogo str., Samara region, 443010, Russia tawerka40@gmail.com

Introduction

Modern server-side web applications face increasing demands to handle a large number of simultaneous requests. As the number of users increases and operations become more complex, especially in applications running with APIs, databases, and external services, server-side performance becomes critical. In this context, the choice between asynchronous and multithreaded approaches becomes very important.

Asynchronous technologies such as Node.js (event loop), Python Asyncio (concurrency, managed events), Go (goroutines), Kotlin Coroutines, offer opportunities to improve performance due to non-blocking I/O operations and ease of managing a large number of simultaneous connections. On the other hand, multithreaded models such as Java Threading and Python Threading provide reliability and simplicity of logic, but can have overhead costs when creating a large number of threads. ^{[1, c.93-95],[2]}

This article examines the performance of server-side web applications using asynchronous and multithreaded approaches.

2. Overview of technologies and approaches

Asynchronous event loop.

Asynchronous event loop is represented by technologies such as Node.js and Python Asyncio. This approach involves using a single thread to manage a large number of requests via non-blocking I/O. This allows for high performance in I/O operations, but complicates debugging and requires the use of asynchronous libraries.^[5]

Goroutines and coroutines.

Go and Kotlin Coroutines use lightweight language runtime-driven streams. They provide high parallelism and are particularly effective in resource-intensive tasks. However, the developer needs to explicitly specify competitive computing. ^{[3, c.260-261],[4]}

Multithreaded programming.

The multithreaded model (Java, Python Threading) allocates a separate thread for each request or uses a thread pool. This approach is useful for tasks that require parallel processing, but it requires careful design and synchronization to avoid errors and performance losses. ^{[1, c.93-95]}

The comparative table 2.1 of these technologies is shown below.:

Table 2.1 – comparison of technologies and approaches

3. Research methodology

To conduct the research, a server application with an API in three languages was developed: Java (multithreaded), Node.js (asynchronous), Go (goroutines). The API endpoint processes an incoming request, reads data from the database (delay emulation), and sends a response. Load tests were performed with a different number of simultaneous requests (50, 100, 500, 1000, 5000). The average response time, bandwidth, and server resource usage (CPU, RAM) were evaluated.

4. Implementation

Load tests were performed for different load levels: 50, 100, 500, 1000, and 5000 simultaneous requests, which allowed us to identify how each approach copes with the increased load. For each test scenario, we measured the following parameters:

Average response time is the average time that has elapsed since the server received the request before sending the response to the client. An important indicator for evaluating the responsiveness of an application (Table 4.1).

Table 4.1 – Average response time

Node.js and Go have lower latency under high load due to asynchronous processing and ease of creating new tasks.

Throughput (RPS) is the number of requests that the server is able to process per unit of time (Table 4.2).

Table 4.2 – Throughput

Go leads the way because of the ease of mining and the fast scheduler, followed by Node.js Java is slowing down due to the cost of thread management and context switching.

We used the hey utility to perform load testing.

hey is a modern HTTP server load testing tool written in the Go language. It can be considered a modern analogue of utilities such as ApacheBench or wrk, but with a number of advantages:

- Ease and efficiency: hey allows you to quickly emulate thousands of simultaneous requests, which is ideal for testing the scalability of a system under real load conditions.

- Ease of use: to run the test, it is enough to specify the total number of requests and the number of simultaneous connections.

The integration of the hey utility into the load testing process allowed us to gain a deep understanding of the server's behavior under various load levels, which is a key point in optimizing web applications and ensuring their stable operation even under peak load conditions.^[6]

CPU and RAM usage — how much computing resources the server consumes when processing requests. To investigate them, the Process Explorer utility was used (and also the built-in PowerShell monitoring for a specific Get-Process process | Where-Object { $_.ProcessName -like "java" } | Select-Object Name, CPU, WS). This tool shows the CPU usage, RAM, and other system information for the selected process (Table 4.3). ^[7]

Process Explorer is an advanced utility from Microsoft (Sysinternals) that allows you to monitor active processes in detail and analyze their use of system resources, including CPU (central processing unit) and RAM (RAM). ^[7]

Table 4.3 – CPU and RAM usage

Go consumes the least amount of memory due to the economical goroutines. Node.js stays within the normal range, while Java requires more memory due to the heavy threading model and JVM operation.

Based on the tests performed, it can be concluded that Java is suitable for enterprise applications with complex logic, but loses in terms of resource consumption and latency under very high load. Node.js is great for I/O-dependent tasks and rapid development. Better performance under medium loads. Go is ideal for high-load systems and requires fewer resources. Wins with a large number of requests.

Conclusion

The study showed the importance of choosing the appropriate query processing model for server-side web applications, depending on the specifics of the load. Asynchronous technologies such as Node.js and Go have demonstrated high efficiency in solving tasks related to intensive use of input-output (I/O), ensuring stable performance even under high loads. These technologies have proven to be more preferable in scenarios with a large number of simultaneous requests, where it is important to minimize delays and resource intensity.