JMeter: Latency vs. Load Time
Last updated: January 1, 2024
Mocking is an essential part of unit testing, and the Mockito library makes it easy to write clean and intuitive unit tests for your Java code.
Get started with mocking and improve your application tests using our Mockito guide:
Handling concurrency in an application can be a tricky process with many potential pitfalls. A solid grasp of the fundamentals will go a long way to help minimize these issues.
Get started with understanding multi-threaded applications with our Java Concurrency guide:
Spring 5 added support for reactive programming with the Spring WebFlux module, which has been improved upon ever since. Get started with the Reactor project basics and reactive programming in Spring Boot:
Since its introduction in Java 8, the Stream API has become a staple of Java development. The basic operations like iterating, filtering, mapping sequences of elements are deceptively simple to use.
But these can also be overused and fall into some common pitfalls.
To get a better understanding on how Streams work and how to combine them with other language features, check out our guide to Java Streams:
Explore Spring Boot 3 and Spring 6 in-depth through building a full REST API with the framework:
Yes, Spring Security can be complex, from the more advanced functionality within the Core to the deep OAuth support in the framework.
I built the security material as two full courses - Core and OAuth, to get practical with these more complex scenarios. We explore when and how to use each feature and code through it on the backing project.
You can explore the course here:
Spring Data JPA is a great way to handle the complexity of JPA with the powerful simplicity of Spring Boot.
Get started with Spring Data JPA through the guided reference course:
Refactor Java code safely — and automatically — with OpenRewrite.
Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.
Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.
Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.
Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.
Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.
In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:
Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.
Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.
In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:
1. Overview
Performance testing is a crucial part of software development. It helps reveal bottlenecks and bugs and ensures our applications are responsive. One particularly important aspect is the time a web application needs to load and react to user interactions.
In this article, we’re going to explore two metrics that can help detect and improve load time issues: latency and load time. We’ll learn how these metrics are defined, what distinguishes them from each other, and how to measure them with the performance tool JMeter.
2. Latency and Load Time Metrics in JMeter
In JMeter, latency and load time are both metrics that measure roundtrips. In other words, they both measure the time from when a client sends a request to a server until it receives the response. However, there’s an important difference between these two.
Latency is defined as the time from just before sending the request to just after receiving the first part of the response, whereas load time is the time from just before sending the request to just after receiving the last part of the response.
For both metrics, JMeter includes the time it takes to assemble the request. Latency also includes the time it takes to assemble the first part of the response, and load time includes the time to assemble the entire response. Assembling does not include the rendering of the response or any client-side code execution.
3. How to Measure Latency and Load Time
We can measure latency and load time in JMeter by creating a test plan that sends an HTTP request and uses a View Results Tree Listener.
We’ll start with a test plan that JMeter automatically creates when we open the tool. In our case, let’s rename it to LatencyVsLoadTime:
Next, let’s create a Thread Group, which is the beginning point of every test plan. This is done by right-clicking the test plan and then selecting Add -> Thread (Users) -> Thread Group:
Next, let’s add an HTTP Request by right-clicking the Thread Group and selecting Add -> Sampler -> HTTP Request:
Last but not least, we need a Listener that tracks the results of our request. Let’s add it by right-clicking the Thread Group and selecting Add -> Listener -> View Results Tree:
Now that we have all parts of the test plan in place, let’s configure our HTTP request.
To do this, we select the HTTP Request and set the Path to the URL we want to test. For our example, let’s choose https://www.google.com:
After saving the test plan by clicking the disk icon in the top bar, we can execute it. Let’s select the HTTP Request and click the play button in the top bar:
Finally, let’s check the results by selecting the View Results Tree element under the Sampler result tab. In our example, the request has a latency of 215 ms and a load time of 218 ms:
4. Conclusion
In this article, we’ve discussed two performance metrics, latency and load time, that can help to detect load time issues and improve the usability of an application.
First, we defined the metrics in the context of JMeter and elaborated on the difference between the two. Then, we saw how to set up a JMeter test plan with an HTTP request that we could use to measure the metrics. Finally, we learned how to execute the test plan and examine the results.
