Although Amdahl's Law explains the scalability of any system, real applications show quite different scalability results. After some research in the area, Neil Gunther found that, despite serialization, there is another, more crucial point, which is called incoherence.

Incoherence is a common phenomenon in a concurrent system with shared resources. For instance, from a standard Java web application perspective, such incoherence is exposed in chaotic Thread access to resources such as the CPU. The entire Java threading model is not ideal. In a case with many more Thread instances than actual processors, there is a direct conflict between the different Thread instances for accessing the CPU and for achieving cycles for their computations. This requires additional effort to resolve their redundant coordination and coherence. Each access to the shared memory from a Thread may require additional synchronization and decrease the throughput and latency of the application. 

In order to explain such behavior in the system, the Universal Scalability Law (USL) extension of Amdahl's Law provides the following formula for calculating throughput changes depending on parallelization:

The preceding formula introduces a coefficient of coherence (k). The most notable thing here is that, from now on, there will be quadratic backward throughput X(N) relation on the parallelization N.

In order to understand the fatal effect of this connection, let's take a look at the following diagram, where we have the same as before—the initial throughput X(1) = 50, the coefficient of contention σ  = 0,03, and the coefficient of coherence k = 0,00007:

From the preceding plot, we can observe that there is a crisis point after which the throughput starts degrading. Moreover, for a better representation of real system scalability, the graph shows both the system scalability as modeled by the USL and the system scalability as modeled by Amdahl's Law. The average response time degradation curve has also changed its behavior. The following diagram shows the latency changes depending on parallelization:

Similarly, for the purpose of showing a contrast, the latency change curve modeled by the USL is compared with the same curve modeled by Amdahl's Law. As we can see from the previous plots, the system behaves differently when there are shared points of access, which may be incoherent and require additional synchronization. A schematic example of such a system is depicted in the following diagram:

As we can see, the whole picture of the system may be much more complex than that which was initially introduced by Little's Law. There are a lot of hidden pitfalls, which may directly impact the scalability of the system.

To conclude these three sections, the overall understanding of these laws plays an important role in modeling a scalable system and planning system capacity. These laws may be applicable to a complex high-load distributed system, as well as to multi-processor nodes with a web application built with the Spring Framework. In addition, understanding what impacts system scalability allows to design the system properly and avoid pitfalls such as incoherence and contention. It also enables to properly analyze WebFlux and Web MVC modules from the laws' perspectives, and predict which scales will perform the best.