Understanding Context Design in Objective‑C: Concepts, Nested Contexts, Thread Safety, and an Event Bus Example

This article introduces the notion of a "Context" in software design, defines it as an abstraction that records state for a specific scenario, and explains where such contexts appear (e.g., ImageContext in UIKit drawing).

What is Context

A context records information for a particular execution interval (e.g., between Begin and End ) and influences the behavior of other methods during that interval. It is commonly named with the suffix Context and appears in many frameworks, including GoF Interpreter patterns.

Nested Contexts

A robust context must support nesting so that information set in interval A does not affect interval B. The implementation should create separate context objects for each nested scope, typically by modeling a parent‑child relationship.

Below is a simplified code sketch that creates distinct context instances for nested intervals (exception handling omitted for brevity).

Thread‑Safety Issues

When a context is accessed from multiple threads, the shared static variable (e.g., [XXContext current] ) can lead to nondeterministic behavior because the execution order is not guaranteed.

To solve this, the context should be bound to a single thread, using Thread‑Local Storage (TLS). In Objective‑C, TLS can be achieved via NSThread 's threadDictionary property.

The revised implementation replaces the static sXXContext variable with [NSThread currentThread].threadDictionary[@"xx-ctx"] , ensuring each thread has its own isolated context.

Implementation Example – Event Bus

The article also presents a lightweight event‑bus library ( https://github.com/prinsun/MKXEventBus ) that demonstrates strong‑typed event publishing, event merging, block/selector subscription, dispatch‑queue specification (using context), and automatic weak‑reference cleanup.

Strong‑typed event publishing

Automatic merging of compatible events

Subscriptions via blocks or selectors

Ability to specify a dispatch queue for callbacks (leveraging context)

Weak‑reference based subscriber cleanup

Typical usage shows beginSubscribe and endSubscribe acting as a context boundary, similar to the concepts described earlier.

What to Do Next

Beyond short‑lived contexts, developers can explore longer‑lived contexts such as application, service, or account contexts, all sharing the core idea of isolated storage.

Use the principles described here to design robust, thread‑safe context mechanisms in your own mobile projects.