Hi Habr! And so, on the fourteenth day of the spear, I decided to start making a simple game server for simple online shooting. For one topic of distributed computing to touch. In this introductory article of the cycle I want to tell what actors are (in Orleans they are called grains) and the principle of their work. For this, I'm still an example of a simple application with home-made actors without Orleans. As they say before building a ship, let's see how it floats and why an ordinary paper boat floats. For details, welcome to cat.Content
- Game Server on MS Orleans - Part 1: What are Actors
Actors
An actor is a computational entity that, in response to a received message, can simultaneously:send a finite number of messages to other actors;create a finite number of new actors;Select the behavior that will be used when processing the next received message.It is not assumed that a certain sequence of the above actions exists, and all of them can be performed in parallel.We send the actor some messages (Teams or Events) and he himself can send others the same messages. Coroutines with channels work on a similar principle. They receive some data from the channel and send some data to the channel while working asynchronously.Example
Actually the code for two very simple actors: class Program
{
interface IMessage { }
class IncrementCommand : IMessage { }
class TellCountCommand : IMessage { }
class SaidCountEvent : IMessage
{
public int Count { get; }
public int ActorId { get; }
public SaidCountEvent(int count, int actorId)
{
Count = count;
ActorId = actorId;
}
}
class WriteMessageCommand : IMessage
{
public string Message { get; }
public WriteMessageCommand(string message)
{
Message = message;
}
}
static Task CreateCounterActor(
BlockingCollection<IMessage> output,
BlockingCollection<IMessage> input,
int id
)
{
return Task.Run(() =>
{
var count = 0;
while (true)
{
var m = input.Take();
if (m is IncrementCommand)
count++;
if (m is TellCountCommand)
output.Add(new SaidCountEvent(count, id));
}
});
}
static Task CreateWriterActor(BlockingCollection<IMessage> input)
{
return Task.Run(() =>
{
while (true)
{
var m = input.Take();
if (m is WriteMessageCommand write)
Console.WriteLine(write.Message);
if (m is SaidCountEvent sc)
Console.WriteLine(
$"Counter {sc.Count} {sc.ActorId}"
);
}
});
}
static void Main(string[] args)
{
var writerInput = new BlockingCollection<IMessage>();
var firstInput = new BlockingCollection<IMessage>();
var secondInput = new BlockingCollection<IMessage>();
var writer = CreateWriterActor(writerInput);
var firstCounter = CreateCounterActor(writerInput, firstInput, 1);
var secondCounter = CreateCounterActor(writerInput, secondInput, 2);
for (int i = 0; i < 5; i++)
{
firstInput.Add(new IncrementCommand());
}
for (int i = 0; i < 9; i++)
{
secondInput.Add(new IncrementCommand());
}
firstInput.Add(new TellCountCommand());
secondInput.Add(new TellCountCommand());
writerInput.Add(new WriteMessageCommand(" Main"));
Console.ReadLine();
}
}
- The interface by which we mark messages that the actor receives or sends:
interface IMessage { }
- The command with which we tell the actor to increase his counter (internal state):
class IncrementCommand : IMessage { }
- The command with the help of which we tell the actor to tell his current state (counter) to others:
class TellCountCommand : IMessage { }
- An event that tells other actors that the actor has told everyone his current state (counter). Generated when the TellCountCommand command is processed:
class SaidCountEvent : IMessage
{
public int Count { get; }
public int ActorId { get; }
public SaidCountEvent(int count, int actorId)
{
Count = count;
ActorId = actorId;
}
}
Count is how much is now dialed on the counter of an actor with an identifier equal to ActorId
- This command tells the actor to print this message to the console:
class WriteMessageCommand : IMessage
{
public string Message { get; }
public WriteMessageCommand(string message)
{
Message = message;
}
}
- Starts an actor instance that controls the current state of the counter:
static Task CreateCounterActor(
//
BlockingCollection<IMessage> output,
//
BlockingCollection<IMessage> input,
//
int id
)
{
return Task.Run(() =>
{
var count = 0;
while (true)
{
var m = input.Take();
if (m is IncrementCommand)
count++;
if (m is TellCountCommand)
output.Add(new SaidCountEvent(count, id));
}
});
}
- Creates an actor who simply writes messages to the console:
static Task CreateWriterActor(BlockingCollection<IMessage> input)
{
return Task.Run(() =>
{
while (true)
{
var m = input.Take();
if (m is WriteMessageCommand write)
Console.WriteLine(write.Message);
if (m is SaidCountEvent sc)
Console.WriteLine(
$"Counter {sc.Count} {sc.ActorId}"
);
}
});
}
static void Main(string[] args)
{
var writerInput = new BlockingCollection<IMessage>();
var firstInput = new BlockingCollection<IMessage>();
var secondInput = new BlockingCollection<IMessage>();
var writer = CreateWriterActor(writerInput);
var firstCounter = CreateCounterActor(writerInput, firstInput, 1);
var secondCounter = CreateCounterActor(writerInput, secondInput, 2);
for (int i = 0; i < 5; i++)
{
firstInput.Add(new IncrementCommand());
}
for (int i = 0; i < 9; i++)
{
secondInput.Add(new IncrementCommand());
}
firstInput.Add(new TellCountCommand());
secondInput.Add(new TellCountCommand());
writerInput.Add(new WriteMessageCommand(" Main"));
Console.ReadLine();
}
Well, so that it would be absolutely beautiful and look like the grale (actor) from Orleans, let's make a wrapper on our counter: public interface ICounterActor
{
void Increment();
void TellCount();
}
public class CounterActor : ICounterActor
{
private readonly Task _taks;
private readonly BlockingCollection<IMessage> _input;
private readonly BlockingCollection<IMessage> _output;
public CounterActor(BlockingCollection<IMessage> output)
{
_input = new BlockingCollection<IMessage>(); ;
_output = output;
_taks = Task.Run(() =>
{
var count = 0;
while (true)
{
var m = _input.Take();
if (m is IncrementCommand)
count++;
if (m is TellCountCommand)
_output.Add(new SaidCountEvent(count, _taks.Id));
}
});
}
public void Increment()
{
_input.Add(new IncrementCommand());
}
public void TellCount()
{
_input.Add(new TellCountCommand());
}
}
Here a reactive model was used. Our actors do not return values, but only generate new messages with the desired values. Here we have one actor just in its own thread, thread safe from everyone else, increases its counter. Another actor just writes to the console. However, let’s imagine that for us each actor, for example, calculates the current coordinates, health and manna of one of the ten players who are currently playing on our server. Each with its own state in its own flow. We send messages to others or receive messages from others about the damage received, the skill used or the change of our coordinates.