面试题：Flutter懒加载策略下的资源释放与内存优化

使用StatefulWidget的生命周期方法：

在State类中，dispose方法会在组件从树中移除时被调用。当使用异步任务进行懒加载时，可以在dispose方法中取消相关异步任务。
例如，使用Future进行数据加载：

class MyLazyLoadPage extends StatefulWidget {
  @override
  _MyLazyLoadPageState createState() => _MyLazyLoadPageState();
}

class _MyLazyLoadPageState extends State<MyLazyLoadPage> {
  Future? _loadDataFuture;
  @override
  void initState() {
    super.initState();
    _loadDataFuture = _loadData();
  }

  Future _loadData() async {
    // 模拟异步加载数据
    await Future.delayed(Duration(seconds: 2));
    return "Loaded Data";
  }

  @override
  void dispose() {
    if (_loadDataFuture != null) {
      // 这里可以考虑取消Future，如果Future支持取消（例如使用Completer手动管理）
      // 简单示例：如果是自己用Completer创建的Future，可以在dispose时调用completer.complete()来结束任务
      _loadDataFuture = null;
    }
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('Lazy Load Page'),
      ),
      body: FutureBuilder(
        future: _loadDataFuture,
        builder: (context, snapshot) {
          if (snapshot.connectionState == ConnectionState.waiting) {
            return Center(child: CircularProgressIndicator());
          } else if (snapshot.hasError) {
            return Center(child: Text('Error: ${snapshot.error}'));
          } else {
            return Center(child: Text('Data: ${snapshot.data}'));
          }
        },
      ),
    );
  }
}

使用Stream和StreamSubscription：

如果使用Stream进行异步数据加载（比如实时数据更新），可以在dispose方法中取消StreamSubscription。
示例：

class MyStreamLazyLoadPage extends StatefulWidget {
  @override
  _MyStreamLazyLoadPageState createState() => _MyStreamLazyLoadPageState();
}

class _MyStreamLazyLoadPageState extends State<MyStreamLazyLoadPage> {
  StreamSubscription? _streamSubscription;
  @override
  void initState() {
    super.initState();
    final stream = Stream.periodic(Duration(seconds: 1), (count) => count);
    _streamSubscription = stream.listen((data) {
      // 处理数据
      print('Received data: $data');
    });
  }

  @override
  void dispose() {
    if (_streamSubscription != null) {
      _streamSubscription!.cancel();
      _streamSubscription = null;
    }
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('Stream Lazy Load Page'),
      ),
      body: Center(
        child: Text('Using Stream for lazy load'),
      ),
    );
  }
}

使用Isolate（适用于更复杂的异步任务）：

当使用Isolate进行异步计算等任务时，在页面不需要时，可以向Isolate发送消息让其停止任务并关闭自身。
示例：

// 隔离代码
void isolateFunction(SendPort sendPort) {
  // 模拟复杂计算
  for (int i = 0; i < 1000000; i++) {
    // 一些计算
  }
  sendPort.send('Isolate finished');
}

class MyIsolateLazyLoadPage extends StatefulWidget {
  @override
  _MyIsolateLazyLoadPageState createState() => _MyIsolateLazyLoadPageState();
}

class _MyIsolateLazyLoadPageState extends State<MyIsolateLazyLoadPage> {
  Isolate? _isolate;
  @override
  void initState() {
    super.initState();
    ReceivePort receivePort = ReceivePort();
    _isolate = Isolate.spawn(isolateFunction, receivePort.sendPort);
    receivePort.listen((message) {
      print('Received from isolate: $message');
    });
  }

  @override
  void dispose() {
    if (_isolate != null) {
      _isolate!.kill(priority: Isolate.immediate);
      _isolate = null;
    }
    super.dispose();
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: Text('Isolate Lazy Load Page'),
      ),
      body: Center(
        child: Text('Using Isolate for lazy load'),
      ),
    );
  }
}

通过上述方法，利用Flutter组件的生命周期以及异步相关机制，可以合理地释放因懒加载创建的异步任务所占用的资源，防止内存泄漏。

星途面试题库

面试题：Flutter懒加载策略下的资源释放与内存优化

知识考点

面试题答案