How to Measure Async Write Latency in Server‑Side Applications

In server‑side performance optimization, a technique called asynchronous write moves database‑write operations to a background task, allowing the main flow to continue without waiting for a response. Unlike asynchronous queries, which must wait for results, asynchronous writes can discard the result entirely or push the task into a dedicated queue. This approach is especially suitable for scenarios with low real‑time requirements, such as recording user purchase information, updating points, or adjusting membership levels. Common examples of asynchronous processing include logging and telemetry systems.

The downside of asynchronous writes is the introduction of latency . Developers often set latency thresholds, but under load testing the observed latency can become much larger than acceptable. Therefore, it is essential to measure the baseline latency of the write operation without any pressure, so that realistic service‑load data can be derived.

The following example demonstrates a latency‑testing solution for an API that updates a user's personal information. The test repeatedly invokes the update, then repeatedly reads the user data until the change is reflected, recording timestamps to calculate both the write latency and the read‑verification latency.

package com.okayqa.teacherpad

import com.fun.utils.RString
import com.okayqa.teacherpad.base.OkayBase
import com.okayqa.teacherpad.function.UserInfo

class T extends OkayBase {
    public static void main(String[] args) {
        def base = getBase()
        def info = new UserInfo(base)
        def total = []
        def diff = []
        100.times {
            def uname = RString.getString(5)
            def result = info.updateInfo(1, uname)
            int i
            if (isRight(result)) {
                def mark0 = getNanoMark()
                while (true) {
                    def mark00 = getNanoMark()
                    def userinfo = info.getUserInfo()
                    def mark01 = getNanoMark()
                    diff << mark01 - mark00
                    if (userinfo.getUserInfo().getString("uname") == uname) break
                    if (i++ > 5) break
                }
                def mark1 = getNanoMark()
                total << mark1 - mark0
            } else {
                fail()
            }
        }
        // Two ways to calculate the average
        def var = diff.sum() / diff.size()
        def average = total.stream().mapToInt().average()
        output "Single‑update latency ≈ ${average - var / 2}"
    }
}

The parameters (such as the number of iterations, timeout limits, and the size of the random username) can be tuned according to the actual environment. During a load test, the latency test can be run in a separate process to observe how the asynchronous write behaves under realistic traffic.