Merge pull request #62 from qmuntal/concstring

Support concurrent state machine reads

Author: qmuntal

statemachine.go

@@ -75,6 +75,7 @@ type StateMachine struct {
 	eventQueue             list.List
 	firingMode             FiringMode
 	firingMutex            sync.Mutex
+	stateMutex             sync.RWMutex
 }
 
 func newStateMachine() *StateMachine {
@@ -295,22 +296,28 @@ func (sm *StateMachine) setState(ctx context.Context, state State) error {
 	return sm.stateMutator(ctx, state)
 }
 
-func (sm *StateMachine) currentState(ctx context.Context) (sr *stateRepresentation, err error) {
-	var state State
-	state, err = sm.State(ctx)
-	if err == nil {
-		sr = sm.stateRepresentation(state)
+func (sm *StateMachine) currentState(ctx context.Context) (*stateRepresentation, error) {
+	state, err := sm.State(ctx)
+	if err != nil {
+		return nil, err
 	}
-	return
+	return sm.stateRepresentation(state), nil
 }
 
-func (sm *StateMachine) stateRepresentation(state State) (sr *stateRepresentation) {
-	var ok bool
-	if sr, ok = sm.stateConfig[state]; !ok {
-		sr = newstateRepresentation(state)
-		sm.stateConfig[state] = sr
+func (sm *StateMachine) stateRepresentation(state State) *stateRepresentation {
+	sm.stateMutex.RLock()
+	sr, ok := sm.stateConfig[state]
+	sm.stateMutex.RUnlock()
+	if !ok {
+		sm.stateMutex.Lock()
+		defer sm.stateMutex.Unlock()
+		// Check again, since another goroutine may have added it while we were waiting for the lock.
+		if sr, ok = sm.stateConfig[state]; !ok {
+			sr = newstateRepresentation(state)
+			sm.stateConfig[state] = sr
+		}
 	}
-	return
+	return sr
 }
 
 func (sm *StateMachine) internalFire(ctx context.Context, trigger Trigger, args ...any) error {
@@ -354,7 +361,7 @@ func (sm *StateMachine) internalFireQueued(ctx context.Context, trigger Trigger,
 	return nil
 }
 
-func (sm *StateMachine) internalFireOne(ctx context.Context, trigger Trigger, args ...any) (err error) {
+func (sm *StateMachine) internalFireOne(ctx context.Context, trigger Trigger, args ...any) error {
 	sm.ops.Add(1)
 	defer sm.ops.Add(^uint64(0))
 	var (
@@ -366,7 +373,7 @@ func (sm *StateMachine) internalFireOne(ctx context.Context, trigger Trigger, ar
 	}
 	source, err := sm.State(ctx)
 	if err != nil {
-		return
+		return err
 	}
 	representativeState := sm.stateRepresentation(source)
 	var result triggerBehaviourResult
@@ -397,7 +404,7 @@ func (sm *StateMachine) internalFireOne(ctx context.Context, trigger Trigger, ar
 			err = sr.InternalAction(ctx, transition, args...)
 		}
 	}
-	return
+	return err
 }
 
 func (sm *StateMachine) handleReentryTrigger(ctx context.Context, sr *stateRepresentation, transition Transition, args ...any) error {

statemachine_test.go

@@ -1513,6 +1513,21 @@ func TestStateMachine_String(t *testing.T) {
 	}
 }
 
+func TestStateMachine_String_Concurrent(t *testing.T) {
+	// Test that race mode doesn't complain about concurrent access to the state machine.
+	sm := NewStateMachine(stateA)
+	const n = 10
+	var wg sync.WaitGroup
+	wg.Add(n)
+	for i := 0; i < n; i++ {
+		go func() {
+			defer wg.Done()
+			_ = sm.String()
+		}()
+	}
+	wg.Wait()
+}
+
 func TestStateMachine_Firing_Queued(t *testing.T) {
 	sm := NewStateMachine(stateA)