actor = new Actor();
actor.sendMessage(new CalculateSomething(1, 2, 3));
//Все, здесь ничего больше не делается, и если даже этот код
//является частью другого актора, в 99 процентах случаях он либо не
//получает других сообщений кроме CalculationResult,
//а если и получает, то ничего не может с ними сделать без CalculationResult

actor = new Actor();
actor.sendMessage(new CalculateSomething(1, 2, 3));
someHardCalculation();

actor = new Actor();
actor.sendMessage(new CalculateSomething(1, 2, 3));
actor.sendMessage(new CalculateSomething(4, 5, 6));
calc = someHardCalculation();

calc = new Calculator();
calc1Future = calc.calculate(1, 2, 3);
calc2Future = calc.calculate(4, 5, 6);
calc = someHardCalculation();
result = resultCalculation(calc, calc1Future.get(), calc2Future.get());

sessionLock.lock();
try {
    commonDataLock.lock();
    try {
        //Непродолжительная обработка
        executeLogic(message, session, commonData);
    } finally {
      commonDataLock.unlock();
    }
} {
  sessionLock.unlock();
}

activateState1();
actor1.sendMessage(new Request1(data1));
actor2.sendMessage(new Request2(data2));
state = STATE1_WAIT_FOR_RESPONSE1_RESPONSE2;

void response1Handler(Response1 resp) {
     this.resp1 = resp;
     if (state == STATE1_WAIT_FOR_RESPONSE1_RESPONSE2) {
         state = STATE1_WAIT_FOR_RESPONSE2;
     } else if (state == STATE1_WAIT_FOR_RESPONSE1){
       process(this.resp1, this.resp2);
       someCommonForState1State2Processing();
       state = STATE1_PROCESSED;
     } else if (state == STATE2_WAIT_FOR_RESPONSE1) {
       //Здесь другой контекст (STATE2) и совершенно другое вычисление
       doAnotherProcessing(this.resp1);
       someCommonForState1State2Processing();
       state = STATE2_PROCESSED;
     } else if (...){}//Обработка других комбинаций
}

void response2Handler(Response2 resp) {
     this.resp2 = resp;
     if (state == STATE1_WAIT_FOR_RESPONSE1_RESPONSE2) {
         state = STATE1_WAIT_FOR_RESPONSE1;
     } else if (state == STATE1_WAIT_RESPONSE2) {
       process(this.resp1, this.resp2);
       someCommonForState1State2Processing();
       state = STATE1_PROCESSED;
     }
}

ProcessingResult process(data1, data2) {
      future1 = performer1.request(new Request1(data1));
      future2 = performer2.request(new Request2(data2));
      return process(future1.get(), future2.get());
}

ProcessingResult2 processAnother(data) {
      return performer1.request(new Request1(data));
}

Actors are awesome. But they aren't the only abstraction we have. Futures are another great abstraction which work very well with purely functional code. Actors are great for maintaining state, futures are great for everything else.

if (state == MONITORING_STATE) {
    if (enemy.getPosition().distance(player.getPosition()) < OBSERVATION_DISTANCE) {
        state = APPROACH_TO_ENEMY;
        player.MoveTo(directionToEnemy...);
    }
} else if (state == APPROACH_TO_ENEMY) {
    player.MoveTo(directionToEnemy...);
    if (enemy.getPosition().distance(player.getPosition()) < ATTACK_DISTANCE)
        state = ATTACK_STATE;
} else if (state == ATTACK_STATE) {
    //..Фаза атаки (за один фрейм)
}

if (enemy.getPosition().distance(player.getPosition() < OBSERVATION_DISTANCE) {
    while (enemy.getPosition().distance(player.getPosition() > ATTACK_DISTANCE) {
        player.MoveTo(directionToEnemy...);//Смещение в направлении врага на расстояние, которое может быть пройдено за один фрейм
        yield return null;
    }
    attack(enemy, player);//Начинается атака, которая ТОЖЕ может быть записана в виде ЛИНЕЙНОГО кода
}

LP>if (state == 1) {
LP>    fsmState = WAIT_FOR_RESPONSE1;
LP>    call(request1);
LP>}
LP>else if (state == 2) {
LP>    fsmState = WAIT_FOR_RESPONSE2;
LP>    call(request2);
LP>}

LP>//Обработка
LP>void messageReceived(Response response) {
LP>    if (fsmState == WAIT_FOR_RESPONSE1)
LP>        calc1(response);
LP>    else if (fsmState == WAIT_FOR_RESPONSE2)
LP>        calc2(response);
LP>    else if (fsmState == NO_REQUEST)//здесь сообщение Response пришло без Request
LP>        processEvent(response);
LP>}
LP>

// Описание связей.
fsmState.in(WAIT_FOR_RESPONSE1).event(calc1);
fsmState.in(WAIT_FOR_RESPONSE2).event(calc2);
fsmState.in(NO_REQUEST).event(processEvent);

var oldState = globalResource;
globalResource = new State();
var x = stream.read();  /// вот этот вызов сделаем неблокирующим, шоб сильнее было
... ля-ля-ля
globalResource = oldState;

где то "там"

var oldState = globalResource;
globalResource = new State();
var x = someLongBlockingCall();
... ля-ля-ля
globalResource = oldState;

result read_from_stream(stream s)
{
    while(s.is_good())
    {
        s.read();
    };
    return result(...);
}

Ситуацию может облегчить использование иерархических автоматов — тогда вместо подобной комбинации состояний будет дерево и состояния WAIT_FOR_RESPONSE1_RESPONSE2 будут дочерними по отношению к контекстам STATE1, STATE2, STATE3... Но иерархические автоматы никто в подобных случаях не использует (уже спасибо, если удосужились оформить машину состояний в виде обычного автомата), потому что для этого требуются либо дополнительные телодвижения, либо дополнительная библиотека. Также количество состояний можно сократить с использованием coroutines (в С# — yield return), но они не в каждом языке есть и не каждому разработчику знакомы. А акторы, черт возьми, знакомы уже многим (к сожалению).

void OnClick()
{
    thread([url=UrlCtrl.GetText()]{
        PostMessage(DownloadData(url)); //PostMessage - функция из используемой gui библиотеки
    }).detach();
}
void OnData(Data d)
{
    OutputCtrl.SetText(d);
}

void OnClick() async
(
    OutputCtrl.SetText(await([url=UrlCtrl.GetText()]{return DownloadData(url);})); //async и await - обёртки над сопрограммой/созданием потока
)

actor = new Actor();
actor.sendMessage(new CalculateSomething(1, 2, 3));
someHardCalculation();

//внешний API

message1(Data):
  return gen_server.call({message_pattern_1, Data})

message2(Data):
  return gen_server.call({message_pattern_2, Data})

message3(Data):
  return gen_server.call({message_pattern_3, Data})

//реализация gen_server'а
init():
  return gen_server.init(InitialState)

handle_call({message_pattern_1, Data}, CurrentState):
   обрабатываем message 1
   return {{response1, Data}, NewCurrentState}
handle_call(message_pattern_2, CurrentState):
   обрабатываем message 2
   return {response2, NewCurrentState}
handle_call({message_pattern_3, Data}, CurrentState):
   обрабатываем message 3
   return {response2, NewCurrentState}

Handle = some_module.init()

Response1 = some_module.message1(Handle, Data1)
Response2 = some_module.message2(Handle, Data2)
Response3 = some_module.message3(Handle, Data3)

if (state == 1)//В Callback я знаю, что state == 1, поэтому вызываю calc1
    call(request1, response -> {calc1(response)});
else if (state == 2)//В Callback я знаю, что state == 2, поэтому вызываю calc2
    call(request2, response -> {calc2(response)});

if (state == 1) {
    fsmState = WAIT_FOR_RESPONSE1;
    call(request1);
}
else if (state == 2) {
    fsmState = WAIT_FOR_RESPONSE2;
    call(request2);
}

//Обработка
void messageReceived(Response response) {
    if (fsmState == WAIT_FOR_RESPONSE1)
        calc1(response);
    else if (fsmState == WAIT_FOR_RESPONSE2)
        calc2(response);
    else if (fsmState == NO_REQUEST)//здесь сообщение Response пришло без Request
        processEvent(response);
}

if (state == 1) {
    response = await call(request1);
    calc1(response);
}
else if (state == 2) {
    response = await call(request2);
    calc2(response);
}

//Обрабатываем самопроизвольный приход Response (хотя название Response для сообщения в данном случае не самое удачное)
void messageReceived(Response response) {
    processEvent(response);
}

some_function() ->
   async1(),
   asyn2(),
   asyn3(),

   wait_for_response([]).  %% если мы не хотим блокировать
                           %% выполнение, и эту функцию тоже
                           %% можно вынести в отдельный процесс/поток

wait_for_response(ResponseAccum) when length(ResponseAccum) == 3->
  ResponseAccum; %% возвращаем аккумулированные ответы
wait_for_response(ResponseAccum) ->
 %% при получении ответа просто добавляем ответ в список ответов
 %% и продолжаем ждать. tail call optmization
 %% позволяет делать рекурсивный вызов сколько угодно раз

 %% receive выбирает из сообщений, поступающих в процесс,
 %% те, что соответсвуют паттерну. Ожидание не стоит ничего.
 %% Вплоть до того, что процесс могут просто выключить из очереди
 %% на обработку до тех пор, пока к нему не придет сообщение
 receive
   {response1, Data} -> wait_for_response(ResponseAccum ++ Data)
   {response2, Data} -> wait_for_response(ResponseAccum ++ Data)
   {response3, Data} -> wait_for_response(ResponseAccum ++ Data)
 %% можно опционально добавить таймаут, и не один, если надо
 after
    1000 -> log("все ждем ответа");
    10000 -> 
       log("ответа не дождались, аборт"),
       error("Aborting")
 end.

X = f(),
Y = g(),
Z = h(X, Y).

resp = await cast(actor, msg);//происходит возврат управления из функции, актор готов принимать сообщения

//Отсюда выполнение продолжится, когда придет ответ на запрос
process(resp);

M>X = f(),
M>Y = g(),
M>Z = h(X, Y).
M>

resp = await cast(actor, msg);//происходит возврат управления из функции, актор готов принимать сообщения

//Отсюда выполнение продолжится, когда придет ответ на запрос
process(resp);

Практически все описаные антипаттерны возникают из отсутсвия в языке и среде нативной поддержки собственно модели акторов. Отсюда все эти стенания о спинлоках, задержке сообщений и прочем и прочем. Это не говоря уже об отсутствии необходимой инфраструктуры, следящей за завершением исполнения процессов, изоляции процессов и многого другого. Откуда проистекают стенания о невозможности следить за акторами с «богатым состоянием» и т.п.

M>Я, если честно, не вижу там простого-сложного, и в чем вообще проблема

ProcessingResult process(data1, data2) {
      future1 = performer1.request(new Request1(data1));
      future2 = performer2.request(new Request2(data2));
      return process(future1.get(), future2.get());
}

ProcessingResult2 processAnother(data) {
      return performer1.request(new Request1(data));
}

activateState1();
actor1.sendMessage(new Request1(data1));
actor2.sendMessage(new Request2(data2));
state = STATE1_WAIT_FOR_RESPONSE1_RESPONSE2;



void response1Handler(Response1 resp) {
     this.resp1 = resp;
     if (state == STATE1_WAIT_FOR_RESPONSE1_RESPONSE2) {
         state = STATE1_WAIT_FOR_RESPONSE2;
     } else if (state == STATE1_WAIT_FOR_RESPONSE1){
       process(this.resp1, this.resp2);
       someCommonForState1State2Processing();
       state = STATE1_PROCESSED;
     } else if (state == STATE2_WAIT_FOR_RESPONSE1) {
       //Здесь другой контекст (STATE2) и совершенно другое вычисление
       doAnotherProcessing(this.resp1);
       someCommonForState1State2Processing();
       state = STATE2_PROCESSED;
     } else if (...){}//Обработка других комбинаций
}

void response2Handler(Response2 resp) {
     this.resp2 = resp;
     if (state == STATE1_WAIT_FOR_RESPONSE1_RESPONSE2) {
         state = STATE1_WAIT_FOR_RESPONSE1;
     } else if (state == STATE1_WAIT_RESPONSE2) {
       process(this.resp1, this.resp2);
       someCommonForState1State2Processing();
       state = STATE1_PROCESSED;
     }
}

In computer programming, a callback is a piece of executable code that is passed as an argument to other code, which is expected to call back (execute) the argument at some convenient time.

BOOST_MSM_EUML_TRANSITION_TABLE(( 
    State1 + Response1 [state_(data1)=event(data1),!!state_(data2)] / (process, someCommonForState1State2Processing) == State1_Processed,
    State1 + Response2 [state_(data2)=event(data2),!!state_(data1)] / (process, someCommonForState1State2Processing) == State1_Processed,
    State2 + Response1 / (doAnotherProcessing, someCommonForState1State2Processing) == State2_Processed
),transition_table)

behavior actor(event_based_actor* self)
{
    optional<Data1> data1;
    optional<Data2> data2;
    return {
        [](const Data1& d) {data1=d; if(data2) process(data1, data2);},
        [](const Data2& d) {data2=d; if(data1) process(data1, data2);}
    };
}