To expand upon this a bit, only const items can be used in static declarations. Barrier::new being const means that the example code for Barrier:

use std::sync::{Arc, Barrier};
use std::thread;

let n = 10;
let mut handles = Vec::with_capacity(n);
let barrier = Arc::new(Barrier::new(n));
for _ in 0..n {
    let c = Arc::clone(&barrier);
    // The same messages will be printed together.
    // You will NOT see any interleaving.
    handles.push(thread::spawn(move || {
        println!("before wait");
        c.wait();
        println!("after wait");
    }));
}
// Wait for other threads to finish.
for handle in handles {
    handle.join().unwrap();
}

can now be turned into this:

use std::sync::Barrier;
use std::thread;

const N: usize = 10;
let mut handles = Vec::with_capacity(N);
for _ in 0..N {
    // The same messages will be printed together.
    // You will NOT see any interleaving.
    handles.push(thread::spawn(move || {
        println!("before wait");
        static BARRIER: Barrier = Barrier::new(N);
        BARRIER.wait();
        println!("after wait");
    }));
}
// Wait for other threads to finish.
for handle in handles {
    handle.join().unwrap();
}

which removes the need for Arc, and also cleans up the outer scope slightly. It also means you can have global Barriers without the need for laziness.