1. Bound every whatever that requires memory to some value N

2. For all whatevers that can have a lifetime for your entire program, do that

3. For any whatevers that can't have a lifetime for your entire program (e.g. for a database server like TFA, a connection object would qualify), make a table of size N

4. When you need a whatever (again using a connection object as an example, when listen() returns) grap an unused entry from the table. If there is no unused entry do the appropriate thing (for a connection, it could be sending an error back to the client, just resetting the TCP connection, blocking, or logging the error and restarting the whole server[1]).

5. When you are done with a whatever (e.g. the connection is closed) return it to the table.

Those are the basics; there are some details that matter for doing this well e.g.:

- You probably don't want to do a linear-probe for a free item in the table if N is larger than about

- Don't forget that the call-stack is a form of dynamic allocation, so ensure that all recursion is bounded or you still can OOM in the form of a stack overflow.

I should also note, that for certain values of N, doing things this way is normal:

- When N=1 then it's just a global (or C "static" local variable).

- When N=(number of threads) then it's just a thread-local variable

1: The last one sounds extreme, but for a well understood system, too many connections could mean something has gone terribly wrong; e.g. if you have X client instances running for the database, using connection pools of size Y and you can have 2XY live connections in your database, exceeding N=2XY is a Bad Thing that recovering from might not be possible