Rust中父作用域变量为何提示“生命周期不足”？

我在学习Rust的作用域机制时遇到问题，尝试实现一段简单的音频播放代码：填充缓冲区后播放，但无法编译。

问题代码 #

fn main() {
    let channels: usize = 2;
    let device = initialize_device();
    let config = initialize_configuration(&device, channels as u16);

    let mut stream_buffer = [0.0 as f32; 64];
    {
        let mut oscillator = Oscillator::new(440.0 as f32, 0.0 as f32, 44100.0 as f32, &mut stream_buffer);

        let processor = move |_data: &mut [f32], _: &cpal::OutputCallbackInfo| {
            //FIXME: Send data from oscillator to _data
            oscillator.process();
        };
    
        let stream = build_outputstream(config, device, Box::new(processor));

        let _ = stream.play();

        std::thread::sleep(std::time::Duration::from_millis(2000));
    }
}

编译器错误信息 #

error[E0597]: `stream_buffer` does not live long enough
  --> src\main.rs:42:88
   |
40 |     let mut stream_buffer = [0.0 as f32; 64];
   |         ----------------- binding `stream_buffer` declared here
41 |     {
42 |         let mut oscillator = Oscillator::new(440.0 as f32, 0.0 as f32, 44100.0 as f32, &mut stream_buffer);
   |                                                                                        ^^^^^^^^^^^^^^^^^^ borrowed value does not live long enough
...
49 |         let stream = build_outputstream(config, device, Box::new(processor));
   |                                                         ------------------- cast requires that `stream_buffer` is borrowed for `'static`
...
55 | }
   | - `stream_buffer` dropped here while still borrowed
   |
   = note: due to object lifetime defaults, `Box<dyn for<'a, 'b> FnMut(&'a mut [f32], &'b OutputCallbackInfo) + Send>` actually means `Box<(dyn for<'a, 'b> FnMut(&'a mut [f32], &'b OutputCallbackInfo) + Send + 'static)>`

我原本以为stream_buffer作为栈上变量生命周期延续到程序结束，而boxed后的processor生命周期更短，会在子作用域结束时销毁，但编译器不这么认为。将stream_buffer设为static可以解决问题，但我不想这么做。请问是否必须将stream_buffer设为static？能否让stream_buffer在栈上，同时processor在堆上？

解决方案 #

不需要把stream_buffer设为static，核心问题在于音频回调要求闭包满足'static生命周期——因为CPAL的输出流可能在后台线程运行，Rust无法保证栈上变量的生命周期能覆盖回调的整个执行周期，即使你用sleep等待，编译器也不会认可这种“手动保证”。

要让栈上逻辑的缓冲区配合堆上的processor工作，你需要把缓冲区的所有权转移到堆上，并通过同步机制让回调安全访问，具体步骤如下：

1. 用Arc<Mutex>包装缓冲区：将栈上的数组转移到堆上，Arc允许多线程共享所有权，Mutex保证线程安全的可变访问。
2. 调整Oscillator的设计：让Oscillator持有Arc<Mutex<[f32; 64]>>而非直接引用栈上数组，这样闭包可以获取Oscillator的所有权，同时缓冲区的生命周期满足'static。

修改后的核心代码示例：

use std::sync::{Arc, Mutex};

fn main() {
    let channels: usize = 2;
    let device = initialize_device();
    let config = initialize_configuration(&device, channels as u16);

    // 将缓冲区包装为Arc<Mutex>，转移到堆上
    let stream_buffer = Arc::new(Mutex::new([0.0 as f32; 64]));
    {
        // 克隆Arc给Oscillator
        let oscillator_buffer = Arc::clone(&stream_buffer);
        let mut oscillator = Oscillator::new(440.0, 0.0, 44100.0, oscillator_buffer);

        let processor = move |data: &mut [f32], _: &cpal::OutputCallbackInfo| {
            oscillator.process();
            // 锁定缓冲区并复制数据到输出
            let buffer = stream_buffer.lock().unwrap();
            data.copy_from_slice(&buffer[..data.len()]);
        };
    
        let stream = build_outputstream(config, device, Box::new(processor));

        let _ = stream.play();

        std::thread::sleep(std::time::Duration::from_millis(2000));
    }
}

// 调整Oscillator定义，持有Arc<Mutex<[f32;64]>>
struct Oscillator {
    freq: f32,
    phase: f32,
    sample_rate: f32,
    buffer: Arc<Mutex<[f32; 64]>>,
}

impl Oscillator {
    fn new(freq: f32, phase: f32, sample_rate: f32, buffer: Arc<Mutex<[f32; 64]>>) -> Self {
        Oscillator { freq, phase, sample_rate, buffer }
    }

    fn process(&mut self) {
        let mut buffer = self.buffer.lock().unwrap();
        // 生成音频数据填充缓冲区
        for sample in buffer.iter_mut() {
            *sample = (self.phase * 2.0 * std::f32::consts::PI).sin();
            self.phase += self.freq / self.sample_rate;
            if self.phase >= 1.0 {
                self.phase -= 1.0;
            }
        }
    }
}

为什么这个方案可行？ #

• Arc<Mutex<[f32;64]>>让缓冲区的生命周期变为'static，因为Arc的引用计数会在所有持有者（包括回调闭包和Oscillator）都销毁后才释放缓冲区。
• Mutex确保在回调和Oscillator访问缓冲区时不会出现数据竞争，符合Rust的线程安全要求。
• 闭包通过move获取stream_buffer的Arc克隆，满足回调的'static生命周期要求，同时栈上的原始Arc会在main函数结束时自动清理。

你不需要把缓冲区设为static，通过堆上的同步共享结构就能实现栈上变量逻辑上的“延续”，同时满足Rust的生命周期和线程安全规则。

内容的提问来源于stack exchange，提问作者Régis Ramillien