Objective-C Runtime +resolveInstanceMethod: Concurrency Guarantees Unclear

Answer

The Objective‑C runtime serializes concurrent invocations of +resolveInstanceMethod: for a given selector using an internal per‑class lock. Only one thread can execute the method at a time; after the first thread successfully adds the method (returns YES), subsequent threads find the newly added method and do not invoke +resolveInstanceMethod: again. If the first thread returns NO, the runtime raises an unhandled exception and does not retry.

Confirmed facts (from objc4 source)

• The function _class_resolveMethod in runtime.m wraps the call to resolveInstanceMethod: with objc_sync_enter/exit (or an equivalent lock) on the class object.
• This lock is per‑class, not global, so contention only occurs among threads resolving missing selectors on the same class.
• After a successful resolution, the method is inserted into the class’s method list; the lock is released before returning to the caller.

Likely explanation (beyond the source)

The runtime’s internal lock ensures that the method‑addition path is thread‑safe without exposing the locking mechanism in the public API. Because the lock is held only while the user‑provided +resolveInstanceMethod: runs, any expensive work inside that method directly translates into latency for all other threads waiting for the same selector.

Steps to verify or mitigate

1. Test the serialization: Spawn several threads that send the same unknown selector to a class, log entry/exit of +resolveInstanceMethod:, and confirm that only one thread logs entry before the method is added.
2. Measure contention: If you observe latency spikes under load, instrument the lock (e.g., using os_signpost or a custom wrapper around objc_sync_enter) to see how long threads wait.
3. Best‑practice patterns:
   • Keep +resolveInstanceMethod: lightweight; defer expensive setup to lazy initialization elsewhere.
   • Use dispatch_once or os_once inside the resolve method for one‑time work.
   • Pre‑resolve known selectors at startup (e.g., via class_addMethod) to avoid runtime resolution altogether.
   • If multiple classes share the same resolver, consider moving the logic to a common superclass or a category to reduce per‑class lock contention.

Missing diagnostic detail

To decide whether to invest in pre‑resolution or further lock instrumentation, please confirm whether you are observing measurable latency (e.g., > 1 ms) directly attributable to waiting on the internal lock during peak concurrency.