How does the 'static lifetime influence long term memory?

Question

I would like to have a program that executes one million asynchronous tasks over a long period of time. I want to manage the concurrency dynamically, but we can imagine simpler version with concurrency 20.

I made a system that is using tokio::task::spawn for each of those asynchronous tasks. tokio::task::spawn requires a Future with the 'static lifetime. If I somehow make my futures static, how would that influence my program long term memory consumption? Would there be some memory accumulation of the futures that were already awaited? Or only thing that would actually accumulate is the thing that is making that future 'static?

Could I pass into each future somewhere dummy static data like &str to make the future static but hold no memory after it is awaited? I'm missing some core understanding here.

Answer 1

Answering your question

In general, any reference that is 'static lives for the entire lifetime of the program; it is only deallocated after main exits.

If you have many distinct values that have the 'static lifetime (i.e. they aren't all references to one shared value), each one will take up some amount of memory. Generally that amount of memory is constant throughout the lifetime of your program and should be easy to account for.

See also:

• How to convert a String into a &'static str

Answering your problem

Nothing about futures requires that you must have a 'static lifetime. What you are citing is a bound on generic types that states that any references present must have the static lifetime. That doesn't mean that a reference is required. Instead, use owned values.

See also:

• What does the 'static lifetime mean in a trait bound in a Rust future?
• The compiler suggests I add a 'static lifetime because the parameter type may not live long enough, but I don't think that's what I want
• Thread references require static lifetime?