Race Condition in TCP State Machine Initialization

[luckinxmas]

Race Condition in TCP State Machine Initialization

Description

There is a potential race condition in the TJPConnectStateMachine implementation. When multiple events are sent to the state machine during initialization, the state transitions can become unpredictable due to asynchronous dispatch to the event queue.

Steps to Reproduce

1. Initialize TJPConnectStateMachine with standard rules
2. Immediately send multiple events in quick succession
3. Observe the state transitions behaving unpredictably

Current Behavior

All state machine operations including initialization and event processing are dispatched asynchronously to a serial queue. However, there's no guarantee that state transitions will be processed in the expected order if multiple events are sent before the initialization completes.

Expected Behavior

State machine initialization should be completed synchronously or provide a callback when setup is finished, ensuring that subsequent event processing occurs after the state machine is fully configured.

Code References

// In TJPConnectStateMachine.m
- (void)setupStandardTransitions {
    // Add transitions asynchronously via addTransitionFromState:toState:forEvent:
    [self addTransitionFromState:TJPConnectStateConnected toState:TJPConnectStateDisconnected forEvent:TJPConnectEventForceDisconnect];
    [self addTransitionFromState:TJPConnectStateConnecting toState:TJPConnectStateDisconnected forEvent:TJPConnectEventForceDisconnect];
    // ... more transitions added
}

// Add transition method is asynchronous
- (void)addTransitionFromState:(TJPConnectState)fromState
                       toState:(TJPConnectState)toState
                      forEvent:(TJPConnectEvent)event {
    if (![self validateTransitionFromState:fromState toState:toState forEvent:event]) {
        return;
    }
    
    NSString *key = [NSString stringWithFormat:@"%@:%@", fromState, event];
    _transitions[key] = toState;
}

// Event sending is also asynchronous
- (void)sendEvent:(TJPConnectEvent)event {
    dispatch_async(_eventQueue, ^{
        // Event processing logic
    });
}

Impact

• Unpredictable state transitions during app startup or connection initiation
• Connection failures that are difficult to debug
• Inconsistent connection state that may require app restart to resolve

Proposed Solution

1. Make initialization synchronous and event processing asynchronous:

- (instancetype)initWithInitialState:(TJPConnectState)initialState
                   setupStandardRules:(BOOL)autoSetup {
    if (self = [super init]) {
        // Set up synchronously
        self.currentState = initialState;
        _transitions = [NSMutableDictionary dictionary];
        _stateChangeHandlers = [NSMutableArray array];
        _eventQueue = dispatch_queue_create("com.statemachine.queue", DISPATCH_QUEUE_SERIAL);
        
        if (autoSetup) {
            // Setup standard transitions synchronously
            [self setupStandardTransitionsSync];
        }
    }
    return self;
}

// Synchronous setup method
- (void)setupStandardTransitionsSync {
    // Add transitions directly to the dictionary
    [self addTransitionSynchronously:TJPConnectStateConnected to:TJPConnectStateDisconnected forEvent:TJPConnectEventForceDisconnect];
    [self addTransitionSynchronously:TJPConnectStateConnecting to:TJPConnectStateDisconnected forEvent:TJPConnectEventForceDisconnect];
    // ... more transitions
}

// Synchronous add transition helper
- (void)addTransitionSynchronously:(TJPConnectState)fromState to:(TJPConnectState)toState forEvent:(TJPConnectEvent)event {
    if (![self validateTransitionFromState:fromState toState:toState forEvent:event]) {
        return;
    }
    
    NSString *key = [NSString stringWithFormat:@"%@:%@", fromState, event];
    _transitions[key] = toState;
}

2. Alternatively, provide a completion handler for asynchronous setup:

- (void)setupStandardTransitionsWithCompletion:(void (^)(void))completion {
    dispatch_async(_eventQueue, ^{
        // Setup all transitions
        [self addTransitionFromState:TJPConnectStateConnected toState:TJPConnectStateDisconnected forEvent:TJPConnectEventForceDisconnect];
        // ... more transitions
        
        if (completion) {
            dispatch_async(dispatch_get_main_queue(), ^{
                completion();
            });
        }
    });
}

These changes would ensure proper initialization of the state machine before processing events, preventing race conditions during startup.