Why is &mut Send? How can a thread capture a &mut in safe Rust?

The language docs state:

> &mut T is Send if and only if T is Send

Can somebody provide a code example of where this is actually relevant?
thread::spawn requires its closure to borrow for 'static lifetime, therefore only statics can be borrowed by a thread closure, but safe Rust doesn't allow static mut. Thus, it should not be possible to capture anything in a thread-closure by &mut anyway.

In which use-case can a &mut's Send-ability be of relevance?

A &mut T should be Send on principle (if T is Send); the implementation shouldn't be disregard simply because you can't construct a safe use-case for it (unsafe still exists for a reason).

But there are safe use-cases:

• std::thread::scope provides a way to execute code in other threads while allowing access to local variables. In the linked documentation a &mut i32 is used in another thread, and thus requires Send.

• It is not unsafe to use a &'static mut T and static mut is not the only way to create one. It can be done safely by using Box::leak for example. This should clearly be viable for sending to another thread.

• async tasks may want to be Send while keeping internal mutable references across .await points, and thus require &mut T to implement Send. This is trivially done all the time whether you realize it or not when writing async functions.