def run(self):
    ' This defines the sequence of actions that are taken when the barrier concurrency state is executed\n\n        :return:\n        '
    logger.debug('Starting execution of {0}{1}'.format(self, (' (backwards)' if self.backward_execution else '')))
    self.setup_run()
    child_errors = {}
    final_outcomes_dict = {}
    decider_state = self.states[UNIQUE_DECIDER_STATE_ID]
    try:
        concurrency_history_item = self.setup_forward_or_backward_execution()
        self.start_child_states(concurrency_history_item, decider_state)
        for (history_index, state) in enumerate(self.states.values()):
            if (state is not decider_state):
                self.join_state(state, history_index, concurrency_history_item)
                self.add_state_execution_output_to_scoped_data(state.output_data, state)
                self.update_scoped_variables_with_output_dictionary(state.output_data, state)
                if ('error' in state.output_data):
                    child_errors[state.state_id] = (state.name, state.output_data['error'])
                final_outcomes_dict[state.state_id] = (state.name, state.final_outcome)
        if self.backward_execution:
            return self.finalize_backward_execution()
        else:
            self.backward_execution = False
        decider_state_error = self.run_decider_state(decider_state, child_errors, final_outcomes_dict)
        transition = self.get_transition_for_outcome(decider_state, decider_state.final_outcome)
        if (transition is None):
            transition = self.handle_no_transition(decider_state)
        decider_state.state_execution_status = StateExecutionStatus.INACTIVE
        if (transition is None):
            self.output_data['error'] = RuntimeError('state aborted')
        else:
            if decider_state_error:
                self.output_data['error'] = decider_state_error
            self.final_outcome = self.outcomes[transition.to_outcome]
        return self.finalize_concurrency_state(self.final_outcome)
    except Exception as e:
        logger.error('{0} had an internal error: {1}\n{2}'.format(self, str(e), str(traceback.format_exc())))
        self.output_data['error'] = e
        self.state_execution_status = StateExecutionStatus.WAIT_FOR_NEXT_STATE
        return self.finalize(Outcome((- 1), 'aborted'))
This defines the sequence of actions that are taken when the barrier concurrency state is executed

:return:
def run(self):
    ' This defines the sequence of actions that are taken when the barrier concurrency state is executed\n\n        :return:\n        '
    logger.debug('Starting execution of {0}{1}'.format(self, (' (backwards)' if self.backward_execution else )))
    self.setup_run()
    child_errors = {}
    final_outcomes_dict = {}
    decider_state = self.states[UNIQUE_DECIDER_STATE_ID]
    try:
        concurrency_history_item = self.setup_forward_or_backward_execution()
        self.start_child_states(concurrency_history_item, decider_state)
        for (history_index, state) in enumerate(self.states.values()):
            if (state is not decider_state):
                self.join_state(state, history_index, concurrency_history_item)
                self.add_state_execution_output_to_scoped_data(state.output_data, state)
                self.update_scoped_variables_with_output_dictionary(state.output_data, state)
                if ('error' in state.output_data):
                    child_errors[state.state_id] = (state.name, state.output_data['error'])
                final_outcomes_dict[state.state_id] = (state.name, state.final_outcome)
        if self.backward_execution:
            return self.finalize_backward_execution()
        else:
            self.backward_execution = False
        decider_state_error = self.run_decider_state(decider_state, child_errors, final_outcomes_dict)
        transition = self.get_transition_for_outcome(decider_state, decider_state.final_outcome)
        if (transition is None):
            transition = self.handle_no_transition(decider_state)
        decider_state.state_execution_status = StateExecutionStatus.INACTIVE
        if (transition is None):
            self.output_data['error'] = RuntimeError('state aborted')
        else:
            if decider_state_error:
                self.output_data['error'] = decider_state_error
            self.final_outcome = self.outcomes[transition.to_outcome]
        return self.finalize_concurrency_state(self.final_outcome)
    except Exception as e:
        logger.error('{0} had an internal error: {1}\n{2}'.format(self, str(e), str(traceback.format_exc())))
        self.output_data['error'] = e
        self.state_execution_status = StateExecutionStatus.WAIT_FOR_NEXT_STATE
        return self.finalize(Outcome((- 1), 'aborted'))