Latency spikes during concurrent Sketch API canvas access

Direct answer

There is no verified public documentation describing internal thread queueing for a "Sketch API" render lock, and no documented batching strategy can be confirmed without knowing which product this API belongs to. The name is ambiguous across design tools, graphics libraries, and internal codebases, so any specific claim about queueing internals would be speculation.

What can be stated with confidence follows from the behavior you describe: a single-threaded rendering loop implies that concurrent mutations serialize on a render lock. When several threads contend for that lock, they queue and block, which produces exactly the latency spikes you observe under load. Adding your own Mutexes or Semaphores around API calls increases lock hold time and typically makes real-time performance worse, not better.

Likely explanation vs. confirmed facts

Confirmed: single-threaded rendering loops exist to keep canvas state consistent, and concurrent writers to a shared drawing context must serialize somehow.

Likely, not verified: APIs built this way usually queue draw commands to the main thread and process them sequentially per frame. Your spikes are probably queue wait time, not graphics buffer work — but that distinction needs measurement, not assumption.

Steps for this case

1. Measure before changing anything. Instrument your client to log timestamps immediately before each canvas mutation call and immediately after it returns. The gap between "request submitted" and "execution started" is queue wait; the rest is execution. If queue wait dominates, contention is confirmed.
2. Run a controlled load test with 1, 2, and 4 concurrent mutators and compare latency distributions and frame times. Linear degradation with thread count indicates serialization on the lock.
3. Coalesce updates caller-side. Instead of many small mutations per thread, accumulate changes and submit one batched update per frame or tick per client. Fewer lock acquisitions means less queueing, without adding synchronization primitives around the API.
4. Remove redundant locking. If the API already serializes internally, your Mutex/Semaphore layer only adds hold time. Verify this against the product docs before removing it.

One detail that changes the recommendation

Which exact product and version is this Sketch API, and what language/runtime is the client binding? Queueing behavior and any official batching or off-main-thread command submission pattern are product- and version-specific. With that identified, check the official documentation and release notes for sections on the threading model and render loop, and search the vendor's support channels for documented batching guidance. Treat this draft as a starting hypothesis for human review until those sources are checked.