elixir凤凰提醒功能

Question

I am playing around with elixir and phoenix and tried to implement reminders functionality, ie todo with future datetime, which should alert you at that datetime.

I have the following naive solutions in mind:

1) use simple one for one strategy and for each reminder create a process, which would use timeout and die after completion

2) aggregate all reminders in a single process, store reminders in state, check datetime every few seconds and remove after alerting.

Could someone elaborate on each solution and may be give a more sensible one, thanks

Answer 1

I suggest thinking about scale. let's say you have one server that handles x reminders:

1. In the first solution we have x processes, each with its own timer, when the timer ends it will send a message and die.

2. In the second solution we'll have a single process that will presumably find all the relevant reminders and handle them accordingly

How big is x?

If x is in the thousands and the reminders are short lived then maybe I would say solution number one is better because you have a better fault tolerant design as the 'reminders' are separated by processes, but if x is much bigger then it might not scale well, you would have a lot of processes each with a timer, it's not really recommended.

I would add that if you have long running reminders, let's say a reminder for a year from now, than you would need to have a process running for a year until it expires, this really doesn't scale.

The second solution scales better when you're dealing with a lot of reminders. You would have a timer that maybe runs every second, it will aggregate the relevant reminders that should run approximately at that time and handle them, long running reminders wouldn't be a problem anymore.

Answer 2

I believe the first option is much, much better, both for simplicity and especially for scalability. Erlang was designed to handle a high number of lightweight processes running concurrently in an efficient manner. Processes can also be distributed across many machines in a cluster, so you can essentially scale to infinity.

Starting a new process that simply calls send_after/3 with a "notification dispatcher" process as the target is extremely simple and has a low performance impact - and if something goes wrong and that process dies, you only lose one reminder. All others are isolated and will still fire.

By storing all your reminders in a single process, you're putting yourself in a very uncomfortable position for several reasons:

• If the process dies, all of your reminders are gone. This is probably unacceptable, so you'd need to come up with a way of persisting them to disk so you could recover from a crash... more work, more complexity;
• If the number of reminders grows too high, traversing the entire list every x seconds will be an expensive operation; send_after/3 has a much more efficient scheduling/dispatching mechanism and it's built right in... less work, less complexity;
• If everything is in a single megaprocess, you can't distribute the load across nodes in your cluster, so you're bound by the computing power of the machine running that megaprocess.

In most programming languages, concurrency is extremely hard to do in a safe way, so people avoid it like the plague. In Elixir and Erlang, it's the exact opposite - you want to use it as much as possible, and you see noticeable gains by doing so. Divide and conquer!