深海游弋的鱼 – 第 6 页

Dart语言构造函数中存在异步方法时的处理方法

dart语言构造函数中如果存在异步方法，编程时如果不注意特殊处理的话，很容易使代码出现未定义行为。例如下面的代码：

class MyComponent{
  MyComponent() {
    init();
  }
  init() async{
    var ret = await _init();
    print('$ret');
  }
 
   _init(){
    return Future.delayed(new Duration(seconds: 2), () {
      return "hello";
    });
  }
}
 
void main() {
  var c = new MyComponent();
  print("done");
}

class MyComponent{

MyComponent() {

init();

}

init() async{

var ret = await _init();

print('$ret');

}

_init(){

return Future.delayed(new Duration(seconds: 2), () {

return "hello";

});

}

void main() {

var c = new MyComponent();

print("done");

}

本意是想先输出“hello“ 然后再输出”done",然而输出顺序刚好相反。原因在于init是异步方法，本应该在调用前使用await等待异步方法返回。然而在构造函数中是无法使用await的。那么该如何处理呢？下面是一种方法，使用工厂函数产生类的对象。而工厂函数是异步的，需要配合await使用。虽然能够解决异步构造的问题，但总觉得不够优雅。

import 'dart:async';
import 'dart:io';
 
class MyComponent{
  /// Private constructor
  MyComponent._create() {
    print("_create() (private constructor)");
 
    // Do most of your initialization here, that's what a constructor is for
    //...
  }
 
  _complexAsyncInit(){
    return Future.delayed(new Duration(seconds: 2), () {
      return "hello";
    });
  }
 
  /// Public factory
  static Future<MyComponent> create() async {
    print("create() (public factory)");
 
    // Call the private constructor
    var component = MyComponent._create();
 
    // Do initialization that requires async
    var ret = await component._complexAsyncInit();
    print("async return value: $ret");
 
    // Return the fully initialized object
    return component;
  }
}
 
void main() async {
  var c = await MyComponent.create();
  print("done");
}

import 'dart:async';

import 'dart:io';

class MyComponent{

/// Private constructor

MyComponent._create() {

print("_create() (private constructor)");

// Do most of your initialization here, that's what a constructor is for

//...

}

_complexAsyncInit(){

return Future.delayed(new Duration(seconds: 2), () {

return "hello";

});

}

/// Public factory

static Future<MyComponent> create() async {

print("create() (public factory)");

// Call the private constructor

var component = MyComponent._create();

// Do initialization that requires async

var ret = await component._complexAsyncInit();

print("async return value: $ret");

// Return the fully initialized object

return component;

}

void main() async {

var c = await MyComponent.create();

print("done");

}

输出：

I/flutter (14941): create() (public factory)
I/flutter (14941): _create() (private constructor)
I/flutter (14941): async return value: hello
I/flutter (14941): done

I/flutter (14941): create() (public factory)

I/flutter (14941): _create() (private constructor)

I/flutter (14941): async return value: hello

I/flutter (14941): done

参考链接

Flutter(able) 的单例模式

一个类只允许创建一个实例，那这个类就是一个单例类，这种设计模式就叫作单例设计模式，简称单例模式。

作为最简单的一种设计模式之一，对于单例本身的概念，大家一看就能明白，但在某些情况下也很容易使用不恰当。相比其他语言，Dart 和 Flutter 中的单例模式也不尽相同，本篇文章我们就一起探究看看它在 Dart 和 Flutter 中的应用。

继续阅读Flutter(able) 的单例模式

Dart并发机制详解

Dart 通过 async-await、isolate 以及一些异步类型概念 (例如 Future 和 Stream) 支持了并发代码编程。本篇文章会对 async-await、Future 和 Stream
进行简略的介绍，而侧重点放在 isolate 的讲解上。

在应用中，所有的 Dart 代码都在 isolate 中运行。每一个 Dart 的 isolate 都有独立的运行线程，它们无法与其他 isolate 共享可变对象。在需要进行通信的场景里，isolate 会使用消息机制。尽管 Dart 的 isolate 模型设计是基于操作系统提供的进程和线程等更为底层的原语进行设计的，但在本篇文章中，我们不对其具体实现展开讨论。

大部分 Dart 应用只会使用一个 isolate (即 主 isolate)，同时你也可以创建更多的 isolate，从而在多个处理器内核上达成并行执行代码的目的。

多平台使用时注意

所有的 Dart 应用都可以使用 async-await、Future 和 Stream。
而 isolate 仅针对原生平台的使用进行实现。
使用 Dart 构建的网页应用可以使用 Web Workers 实现相似的功能。

继续阅读Dart并发机制详解

Widget的物理模拟动画效果

物理模拟能够让应用富有真实感和更好的交互性。例如，你可能会为一个 widget 添加动画，让它看起来就像安着弹簧，或是在随重力下落。

这个指南演示了如何将 widget 从拖动的点移回到中心，并使用弹簧模拟效果。

这个演示将进行下面几步：

创建一个动画控制器

使用手势移动 widget

对 widget 进行动画

计算速度以模拟弹跳运动

继续阅读Widget的物理模拟动画效果

Flutter手势交互 ( 跟随手指运动的小球 )

Flutter 手势 - 跟随手指运动的小球

设置小球坐标变量 : 其中 currentX 是距离左侧边界的距离 , currentY 是距离右侧边界的距离 ;

  /// 当前小球的 x 坐标
  double currentX = 0;
  /// 当前小球的 y 坐标
  double currentY = 0;

/// 当前小球的 x 坐标

double currentX = 0;

/// 当前小球的 y 坐标

double currentY = 0;

小球的位置 : 小球是在 Stack 帧布局中的 Positioned 组件 , 其 left 和 top 字段值设置其坐标 , 分别对应 currentX 和 currentY 值 ;

// 小球
Positioned(
  /// 当前位置
  left: currentX,
  top: currentY,
)

// 小球

Positioned(

/// 当前位置

left: currentX,

top: currentY,

)

监听事件 : 监听 GestureDetector 组件的 onPanUpdate 事件 , 其回调方法是 void Function(DragUpdateDetails details) 类型的方法 , 可以从 DragUpdateDetails 类型参数中获取当前 x , y 的移动距离 , 该距离需要与之前的距离累加 , 才能得到准确的坐标值 ;

在回调方法中调用 setState 方法 , 修改成员变量 currentX 和 currentY , 从而修改 Positioned 组件的位置 , 以达到小球移动的目的 ;

/// 手势检测组件
child: GestureDetector(
  /// 移动操作
  onPanUpdate: (e){
    setState(() {
      // e 中只能获取到 delta 值 , 需要逐步累加
      currentX += e.delta.dx;
      currentY += e.delta.dy;
    });
  },
)

/// 手势检测组件

child: GestureDetector(

/// 移动操作

onPanUpdate: (e){

setState(() {

// e 中只能获取到 delta 值 , 需要逐步累加

currentX += e.delta.dx;

currentY += e.delta.dy;

});

)

代码示例 :

// 小球
Positioned(
  /// 当前位置
  left: currentX,
  top: currentY,
  /// 手势检测组件
  child: GestureDetector(
    /// 移动操作
    onPanUpdate: (e){
      setState(() {
        // e 中只能获取到 delta 值 , 需要逐步累加
        currentX += e.delta.dx;
        currentY += e.delta.dy;
      });
    },
    // 黑色小球
    child: Container(
      width: 40,
      height: 40,
      decoration: BoxDecoration(
        color: Colors.black,
        borderRadius: BorderRadius.circular(20),
      ),
    ),
  ),),

// 小球

Positioned(

/// 当前位置

left: currentX,

top: currentY,

/// 手势检测组件

child: GestureDetector(

/// 移动操作

onPanUpdate: (e){

setState(() {

// e 中只能获取到 delta 值 , 需要逐步累加

currentX += e.delta.dx;

currentY += e.delta.dy;

});

// 黑色小球

child: Container(

width: 40,

height: 40,

decoration: BoxDecoration(

color: Colors.black,

borderRadius: BorderRadius.circular(20),

),),

完整代码示例

完整代码示例 :

import 'package:flutter/foundation.dart';
import 'package:flutter/material.dart';

class GesturePage extends StatefulWidget {
  const GesturePage({Key? key}) : super(key: key);

  @override
  _GesturePageState createState() => _GesturePageState();
}

class _GesturePageState extends State<GesturePage> {
  /// 当前小球的 x 坐标
  double currentX = 0;

  /// 当前小球的 y 坐标
  double currentY = 0;

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      // 设置主题
      theme: ThemeData(
        primarySwatch: Colors.amber,
      ),

      // 设置主体组件
      home: Scaffold(
        // 设置标题栏
        appBar: AppBar(
          title: const Text("手势检测"),

          // 返回按钮设置
          leading: GestureDetector(
            // 点击事件回调函数
            onTap: () {
              // 退出当前界面
              Navigator.pop(context);
            },

            // 回退按钮图标
            child: const Icon(Icons.arrow_back),
          ),
        ),

        // 水平/垂直方向平铺组件
        body: FractionallySizedBox(
          // 水平方向平铺
          widthFactor: 1,

          // 帧布局
          child: Stack(
            children: <Widget>[
              // 垂直方向线性布局
              Column(
                children: <Widget>[
                  // 手势检测组件
                  GestureDetector(
                    // 点击事件
                    onTap: () {
                      if (kDebugMode) {
                        print("双击");
                      }
                    },

                    // 双击事件
                    onDoubleTap: () {
                      if (kDebugMode) {
                        print("双击");
                      }
                    },

                    // 长按事件 , ()=>方法名(参数列表) 即可回调一个现有方法
                    onLongPress: () => _longPress(),

                    // 点击取消
                    onTapCancel: () {
                      if (kDebugMode) {
                        print("点击取消");
                      }
                    },

                    // 点击按下
                    onTapDown: (e) {
                      if (kDebugMode) {
                        print("点击按下");
                      }
                    },

                    // 点击抬起
                    onTapUp: (e) {
                      if (kDebugMode) {
                        print("点击抬起");
                      }
                    },

                    // 手势检测的作用组件 , 监听该组件上的各种手势
                    child: Container(
                      // 子组件居中
                      alignment: Alignment.center,

                      // 内边距
                      padding: const EdgeInsets.all(100),

                      // 背景装饰
                      decoration: const BoxDecoration(
                        color: Colors.green,
                      ),

                      child: const Text(
                        "手势检测",
                        style: TextStyle(
                          fontSize: 50,
                          color: Colors.red,
                        ),
                      ),
                    ),
                  )
                ],
              ),

              // 小球
              Positioned(
                /// 当前位置
                left: currentX,
                top: currentY,

                /// 手势检测组件
                child: GestureDetector(
                  /// 移动操作
                  onPanUpdate: (e) {
                    setState(() {
                      // e 中只能获取到 delta 值 , 需要逐步累加
                      currentX += e.delta.dx;
                      currentY += e.delta.dy;
                    });
                  },

                  // 黑色小球
                  child: Container(
                    width: 40,
                    height: 40,
                    decoration: BoxDecoration(
                      color: Colors.black,
                      borderRadius: BorderRadius.circular(20),
                    ),
                  ),
                ),
              ),
            ],
          ),
        ),
      ),
    );
  }

  /// 长按事件
  void _longPress() {
    if (kDebugMode) {
      print("长按");
    }
  }
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

import 'package:flutter/foundation.dart';

import 'package:flutter/material.dart';

class GesturePage extends StatefulWidget {

const GesturePage({Key? key}) : super(key: key);

@override

_GesturePageState createState() => _GesturePageState();

}

class _GesturePageState extends State<GesturePage> {

/// 当前小球的 x 坐标

double currentX = 0;

/// 当前小球的 y 坐标

double currentY = 0;

@override

Widget build(BuildContext context) {

return MaterialApp(

// 设置主题

theme: ThemeData(

primarySwatch: Colors.amber,

// 设置主体组件

home: Scaffold(

// 设置标题栏

appBar: AppBar(

title: const Text("手势检测"),

// 返回按钮设置

leading: GestureDetector(

// 点击事件回调函数

onTap: () {

// 退出当前界面

Navigator.pop(context);

// 回退按钮图标

child: const Icon(Icons.arrow_back),

// 水平/垂直方向平铺组件

body: FractionallySizedBox(

// 水平方向平铺

widthFactor: 1,

// 帧布局

child: Stack(

children: <Widget>[

// 垂直方向线性布局

Column(

children: <Widget>[

// 手势检测组件

GestureDetector(

// 点击事件

onTap: () {

if (kDebugMode) {

print("双击");

}

// 双击事件

onDoubleTap: () {

if (kDebugMode) {

print("双击");

}

// 长按事件 , ()=>方法名(参数列表) 即可回调一个现有方法

onLongPress: () => _longPress(),

// 点击取消

onTapCancel: () {

if (kDebugMode) {

print("点击取消");

}

// 点击按下

onTapDown: (e) {

if (kDebugMode) {

print("点击按下");

}

// 点击抬起

onTapUp: (e) {

if (kDebugMode) {

print("点击抬起");

}

// 手势检测的作用组件 , 监听该组件上的各种手势

child: Container(

// 子组件居中

alignment: Alignment.center,

// 内边距

padding: const EdgeInsets.all(100),

// 背景装饰

decoration: const BoxDecoration(

color: Colors.green,

child: const Text(

"手势检测",

style: TextStyle(

fontSize: 50,

color: Colors.red,

)

// 小球

Positioned(

/// 当前位置

left: currentX,

top: currentY,

/// 手势检测组件

child: GestureDetector(

/// 移动操作

onPanUpdate: (e) {

setState(() {

// e 中只能获取到 delta 值 , 需要逐步累加

currentX += e.delta.dx;

currentY += e.delta.dy;

});

// 黑色小球

child: Container(

width: 40,

height: 40,

decoration: BoxDecoration(

color: Colors.black,

borderRadius: BorderRadius.circular(20),

);

}

/// 长按事件

void _longPress() {

if (kDebugMode) {

print("长按");

}

继续阅读Flutter手势交互 ( 跟随手指运动的小球 )

Dart 2.15更新后isolate应该这么用

序言

2021年的最后一天, Dart 官方发布了 dart 2.15 版本，该版本优化了很多内容，今天我们要重点说说 isolate 工作器。官方推文链接

在探索新变化之前，我们来回忆巩固一下 isolate 的使用。

isolate 的作用

问题：Flutter 基于单线程模式使用协程进行开发，为什么还需要 isolate ？

首先我们要明确 并行（isolate） 与并发（future）的区别。下面我们通过简单的例子来进行说明。Demo 是一个简单的页面，中间放置一个不断转圈的 progress 和一个按键，按键用来触发耗时方法。

///计算偶数个数（具体的耗时操作）下面示例代码中会用到
static int calculateEvenCount(int num) {
    int count = 0;
    while (num > 0) {
      if (num % 2 == 0) {
        count++;
      }
      num--;
    }
    return count;
  }

///计算偶数个数（具体的耗时操作）下面示例代码中会用到

static int calculateEvenCount(int num) {

int count = 0;

while (num > 0) {

if (num % 2 == 0) {

count++;

}

num--;

}

return count;

}

///按键点击事件
onPressed: () {
      //触发耗时操作
      doMockTimeConsume();
  }

///按键点击事件

onPressed: () {

//触发耗时操作

doMockTimeConsume();

}

方式一：我们将耗时操作使用 future 的方式进行封装

///使用future的方式封装耗时操作
static Future<int> futureCountEven(int num) async {
    var result = calculateEvenCount(num);
    return Future.value(result);
  }

///耗时事件
void doMockTimeConsume() async {
    var result = await futureCountEven(1000000000);
    _count = result;
    setState(() {});
  }

///使用future的方式封装耗时操作

static Future<int> futureCountEven(int num) async {

var result = calculateEvenCount(num);

return Future.value(result);

}

///耗时事件

void doMockTimeConsume() async {

var result = await futureCountEven(1000000000);

_count = result;

setState(() {});

}

结论：使用 future 的方式来消费耗时操作，由于仍然是单线程在进行工作，异步只是在同一个线程的并发操作，仍会阻塞UI的刷新。

方式二：使用 isolate 创建新线程，避开主线程，不干扰UI刷新

//模拟耗时操作
  void doMockTimeConsume() async {
    var result = await isolateCountEven(1000000000);
    _count = result;
    setState(() {});
  }

//模拟耗时操作

void doMockTimeConsume() async {

var result = await isolateCountEven(1000000000);

_count = result;

setState(() {});

}

  ///使用isolate的方式封装耗时操作
  static Future<dynamic> isolateCountEven(int num) async {
    final p = ReceivePort();
    ///发送参数
    await Isolate.spawn(_entryPoint, [p.sendPort, num]);
    return (await p.first) as int;
  }

 static void _entryPoint(SendPort port) {
    SendPort responsePort = args[0];
    int num = args[1];
    ///接收参数，进行耗时操作后返回数据
    responsePort.send(calculateEvenCount(num));
  }

///使用isolate的方式封装耗时操作

static Future<dynamic> isolateCountEven(int num) async {

final p = ReceivePort();

///发送参数

await Isolate.spawn(_entryPoint, [p.sendPort, num]);

return (await p.first) as int;

}

static void _entryPoint(SendPort port) {

SendPort responsePort = args[0];

int num = args[1];

///接收参数，进行耗时操作后返回数据

responsePort.send(calculateEvenCount(num));

}

结论：使用 isolate 实现了多线程并行，在新线程中进行耗时操作不会干扰UI线程的刷新。

isolate 的局限性，为什么需要优化？

iso 有两点较为重要的局限性。

isolate 消耗较重，除了创建耗时，每次创建还至少需要2Mb的空间，有OOM的风险。
isolate 之间的内存空间各自独立，当参数或结果跨 iso 相互传递时需要深度拷贝，拷贝耗时，可能造成UI卡顿。

isolate 新特性

Dart 2.15 更新，给 iso 添加了组的概念，isolate 组 工作特征可简单总结为以下两点：

Isolate 组中的 isolate 共享各种内部数据结构
Isolate 组仍然阻止在 isolate 间共享访问可变对象，但由于 isolate 组使用共享堆实现，这也让其拥有了更多的功能。

官方推文中举了一个例子：

工作器 isolate 通过网络调用获得数据，将该数据解析为大型 JSON 对象图，然后将这个 JSON 图返回到主 isolate 中。

Dart 2.15 之前：执行该操作需要深度复制，如果复制花费的时间超过帧预算时间，就会导致界面卡顿。

使用 Dart 2.15 ：工作器 isolate 可以调用 Isolate.exit()，将其结果作为参数传递。然后，Dart 运行时将包含结果的内存数据从工作器 isolate 传递到主 isolate 中，无需复制，且主 isolate 可以在固定时间内接收结果。

重点：提供 Isolate.exit() 方法，将包含结果的内存数据从工作器 isolate 传递到主 isolate,过程无需复制。

附注：使用 Dart 新特性，需将 flutter sdk 升级到 2.8.0 以上链接。

isolate中：exit 和 send 的区别及用法

Dart 更新后，我们将数据从 工作器 isolate（子线程）回传到 主 isolate（主线程）有两种方式。

方式一：使用 send

responsePort.send(data);

1	responsePort.send(data);

点击进入 send 方法查看源码注释，看到这样一句话：

结论：send 本身不会阻塞，会立即发送，但可能需要线性时间成本用于复制数据。

方式二：使用 exit

Isolate.exit(responsePort, data);

1	Isolate.exit(responsePort, data);

官网给出的解释如下：

结论：隔离之间的消息传递通常涉及数据复制，因此可能会很慢，并且会随着消息大小的增加而增加。但是 exit()，则是在退出隔离中保存消息的内存，不会被复制，而是被传输到主 isolate。这种传输很快，并且在恒定的时间内完成。

我们把上面 demo 中的 _entryPoint 方法做一下优化，修改如下：

 static void _entryPoint(SendPort port) {
    SendPort responsePort = args[0];
    int num = args[1];
    ///接收参数，进行耗时操作后返回数据
    //responsePort.send(calculateEvenCount(num));
    Isolate.exit(responsePort, calculateEvenCount(num));
  }

static void _entryPoint(SendPort port) {

SendPort responsePort = args[0];

int num = args[1];

///接收参数，进行耗时操作后返回数据

//responsePort.send(calculateEvenCount(num));

Isolate.exit(responsePort, calculateEvenCount(num));

}

总结：使用 exit() 替代 SendPort.send，可规避数据复制，节省耗时。

isolate 组

如何创建一个 isolate 组？官方给出的解释如下：

When an isolate calls Isolate.spawn(), the two isolates have the same executable code and are in the same isolate group. Isolate groups enable performance optimizations such as sharing code; a new isolate immediately runs the code owned by the isolate group. Also, Isolate.exit() works only when the isolates are in the same isolate group.

当在 isolate 中调用另一个 isolate 时，这两个 isolate 具有相同的可执行代码，并且位于同一隔离组。

PS：小轰暂时也没有想到具体的使用场景，先暂放一边吧。

实践：isolate 如何处理连续数据

结合上面的耗时方法calculateEvenCount，isolate 处理连续数据需要结合 stream 流的设计。具体 demo 如下：

///测试入口
static testContinuityIso() async {
    final numbs = [10000, 20000, 30000, 40000];
    await for (final data in _sendAndReceive(numbs)) {
      log(data.toString());
    }
  }

///测试入口

static testContinuityIso() async {

final numbs = [10000, 20000, 30000, 40000];

await for (final data in _sendAndReceive(numbs)) {

log(data.toString());

}

///具体的iso实现（主线程）
static Stream<Map<String, dynamic>> _sendAndReceive(List<int> numbs) async* {
    final p = ReceivePort();
    await Isolate.spawn(_entry, p.sendPort);
    final events = StreamQueue<dynamic>(p);

    // 拿到 子isolate传递过来的 SendPort 用于发送数据
    SendPort sendPort = await events.next;
    for (var num in numbs) {
      //发送一条数据，等待一条数据结果，往复循环
      sendPort.send(num);
      Map<String, dynamic> message = await events.next;
      //每次的结果通过stream流外露
      yield message;
    }
    //发送 null 作为结束标识符
    sendPort.send(null);
    await events.cancel();
  }

///具体的iso实现（主线程）

static Stream<Map<String, dynamic>> _sendAndReceive(List<int> numbs) async* {

final p = ReceivePort();

await Isolate.spawn(_entry, p.sendPort);

final events = StreamQueue<dynamic>(p);

// 拿到子isolate传递过来的 SendPort 用于发送数据

SendPort sendPort = await events.next;

for (var num in numbs) {

//发送一条数据，等待一条数据结果，往复循环

sendPort.send(num);

Map<String, dynamic> message = await events.next;

//每次的结果通过stream流外露

yield message;

}

//发送 null 作为结束标识符

sendPort.send(null);

await events.cancel();

}

///具体的iso实现（子线程）
static Future<void> _entry(SendPort p) async {
    final commandPort = ReceivePort();
    //发送一个 sendPort 给主iso ，用于 主iso 发送参数给 子iso
    p.send(commandPort.sendPort);
    await for (final message in commandPort) {
      if (message is int) {
        final data = calculateEvenCount(message);
        p.send(data);
      } else if (message == null) {
        break;
      }
    }
  }

///具体的iso实现（子线程）

static Future<void> _entry(SendPort p) async {

final commandPort = ReceivePort();

//发送一个 sendPort 给主iso ，用于主iso 发送参数给子iso

p.send(commandPort.sendPort);

await for (final message in commandPort) {

if (message is int) {

final data = calculateEvenCount(message);

p.send(data);

} else if (message == null) {

break;

}

参考链接

Dart 2.15 更新后 isolate 应该这么用

Flutter (2.10.1~3.3.9)/Xcode 13.2.1/macOS Big Sur 11.6.4在iPad Pro iOS 15.3.1/iPhone SE 3 iOS 16.1.1真机免费调试

系统与开发环境 Flutter (2.10.1~3.3.9)/Xcode 13.2.1(13C100)/macOS Big Sur 11.6.4/iPad Pro(Model A1673) iOS 15.3.1/iPhone SE 3 iOS 16.1.1

操作步骤

1. 苹果开发网站注册或关联开发者账号，如果暂时不需要发布应用到 Mac App Store，只是在设备上调试应用，则不需要注册收费用户，只需要注册或者关联账号即可。具体可以查看官方介绍选择会员资格。

2. 在 iPad Pro 和 macbook Pro 登陆同一个注册的开发者的账号。

3. 通过 USB 数据线把 iPad Pro 与 macbook Pro 设备连接起来，如下图：

继续阅读Flutter (2.10.1~3.3.9)/Xcode 13.2.1/macOS Big Sur 11.6.4在iPad Pro iOS 15.3.1/iPhone SE 3 iOS 16.1.1真机免费调试

Flutter线程模型&单例

Flutter线程模型

Flutter Engine自己不创建管理线程。Flutter Engine线程的创建和管理是由embedder负责的。Embeder指的是将引擎移植到平台的中间层代码。

Flutter Engine要求Embeder提供四个Task Runner。尽管Flutter Engine不在乎Runner具体跑在哪个线程，但是它需要线程配置在整一个生命周期里面保持稳定。也就是说一个Runner最好始终保持在同一线程运行。这四个主要的Task Runner包括：

Platform Task Runner

Flutter Engine的主Task Runner，运行Platform Task Runner的线程可以理解为是主线程。类似于Android Main Thread或者iOS的Main Thread。但是我们要注意Platform Task Runner和iOS之类的主线程还是有区别的。

对于Flutter Engine来说Platform Runner所在的线程跟其它线程并没有实质上的区别，只不过我们人为赋予它特定的含义便于理解区分。实际上我们可以同时启动多个Engine实例，每个Engine对应一个Platform Runner，每个Runner跑在各自的线程里。这也是Fuchsia（Google正在开发的操作系统）里Content Handler的工作原理。一般来说，一个Flutter应用启动的时候会创建一个Engine实例，Engine创建的时候会创建一个线程供Platform Runner使用。

跟Flutter Engine的所有交互（接口调用）必须发生在Platform Thread，试图在其它线程中调用Flutter Engine会导致无法预期的异常。这跟iOS UI相关的操作都必须在主线程进行相类似。需要注意的是在Flutter Engine中有很多模块都是非线程安全的。一旦引擎正常启动运行起来，所有引擎API调用都将在Platform Thread里发生。

Platform Runner所在的Thread不仅仅处理与Engine交互，它还处理来自平台的消息。这样的处理比较方便的，因为几乎所有引擎的调用都只有在Platform Thread进行才能是安全的，Native Plugins不必要做额外的线程操作就可以保证操作能够在Platform Thread进行。如果Plugin自己启动了额外的线程，那么它需要负责将返回结果派发回Platform Thread以便Dart能够安全地处理。规则很简单，对于Flutter Engine的接口调用都需保证在Platform Thread进行。

需要注意的是，阻塞Platform Thread不会直接导致Flutter应用的卡顿（跟iOS android主线程不同）。尽管如此，平台对Platform Thread还是有强制执行限制。所以建议复杂计算逻辑操作不要放在Platform Thread而是放在其它线程（不包括我们现在讨论的这个四个线程）。其他线程处理完毕后将结果转发回Platform Thread。长时间卡住Platform Thread应用有可能会被系统Watchdog强行杀死。

UI Task Runner Thread（Dart Runner）

UI Task Runner被Flutter Engine用于执行Dart root isolate代码。Root isolate比较特殊，它绑定了不少Flutter需要的函数方法。Root isolate运行应用的main code。引擎启动的时候为其增加了必要的绑定，使其具备调度提交渲染帧的能力。对于每一帧，引擎要做的事情有：
- Root isolate通知Flutter Engine有帧需要渲染。
- Flutter Engine通知平台，需要在下一个vsync的时候得到通知。
- 平台等待下一个vsync
- 对创建的对象和Widgets进行Layout并生成一个Layer Tree，这个Tree马上被提交给Flutter Engine。当前阶段没有进行任何光栅化，这个步骤仅是生成了对需要绘制内容的描述。
- 创建或者更新Tree，这个Tree包含了用于屏幕上显示Widgets的语义信息。这个东西主要用于平台相关的辅助Accessibility元素的配置和渲染。

除了渲染相关逻辑之外Root Isolate还是处理来自Native Plugins的消息响应，Timers，Microtasks和异步IO。
我们看到Root Isolate负责创建管理的Layer Tree最终决定什么内容要绘制到屏幕上。因此这个线程的过载会直接导致卡顿掉帧。
如果确实有无法避免的繁重计算，建议将其放到独立的Isolate去执行，比如使用compute关键字或者放到非Root Isolate，这样可以避免应用UI卡顿。但是需要注意的是非Root Isolate缺少Flutter引擎需要的一些函数绑定，你无法在这个Isolate直接与Flutter Engine交互。所以只在需要大量计算的时候采用独立Isolate。

Raster(GPU) Task Runner

Raster(GPU) Task Runner被用于执行设备GPU的相关调用。UI Task Runner创建的Layer Tree信息是平台不相关，也就是说Layer Tree提供了绘制所需要的信息，具体如何实现绘制取决于具体平台和方式，可以是OpenGL，Vulkan，软件绘制或者其他Skia配置的绘图实现。GPU Task Runner中的模块负责将Layer Tree提供的信息转化为实际的GPU指令。Raster(GPU) Task Runner同时也负责配置管理每一帧绘制所需要的GPU资源，这包括平台Framebuffer的创建，Surface生命周期管理，保证Texture和Buffers在绘制的时候是可用的。

基于Layer Tree的处理时长和GPU帧显示到屏幕的耗时，Raster(GPU) Task Runner可能会延迟下一帧在UI Task Runner的调度。一般来说UI Runner和GPU Runner跑在不同的线程。存在这种可能，UI Runner在已经准备好了下一帧的情况下，Raster(GPU) Runner却还正在向GPU提交上一帧。这种延迟调度机制确保不让UI Runner分配过多的任务给GPU Runner。

前面我们提到Raster(GPU) Runner可以导致UI Runner的帧调度的延迟，Raster(GPU) Runner的过载会导致Flutter应用的卡顿。一般来说用户没有机会向Raster(GPU) Runner直接提交任务，因为平台和Dart代码都无法跑进Raster(GPU) Runner。但是Embeder还是可以向Raster(GPU) Runner提交任务的。因此建议为每一个Engine实例都新建一个专用的Raster(GPU) Runner线程。

IO Task Runner

前面讨论的几个Runner对于执行任务的类型都有比较强的限制。Platform Runner过载可能导致系统WatchDog强杀，UI和GPU Runner过载则可能导致Flutter应用的卡顿。但是GPU线程有一些必要操作是比较耗时间的，比如IO，而这些操作正是IO Runner需要处理的。

IO Runner的主要功能是从图片存储（比如磁盘）中读取压缩的图片格式，将图片数据进行处理为GPU Runner的渲染做好准备。在Texture的准备过程中，IO Runner首先要读取压缩的图片二进制数据（比如PNG，JPEG），将其解压转换成GPU能够处理的格式然后将数据上传到GPU。这些复杂操作如果跑在GPU线程的话会导致Flutter应用UI卡顿。但是只有GPU Runner能够访问GPU，所以IO Runner模块在引擎启动的时候配置了一个特殊的Context，这个Context跟GPU Runner使用的Context在同一个ShareGroup。事实上图片数据的读取和解压是可以放到一个线程池里面去做的，但是这个Context的访问只能在特定线程才能保证安全。这也是为什么需要有一个专门的Runner来处理IO任务的原因。获取诸如ui.Image这样的资源只有通过async call，当这个调用发生的时候Flutter Framework告诉IO Runner进行刚刚提到的那些图片异步操作。这样GPU Runner可以使用IO Runner准备好的图片数据而不用进行额外的操作。

用户操作，无论是Dart Code还是Native Plugins都是没有办法直接访问IO Runner。尽管Embeder可以将一些一般复杂任务调度到IO Runner，这不会直接导致Flutter应用卡顿，但是可能会导致图片和其它一些资源加载的延迟间接影响性能。所以建议为IO Runner创建一个专用的线程。

各个平台目前默认Runner线程实现

前面我们提到Engine Runner的线程可以按照实际情况进行配置，各个平台目前有自己的实现策略。

iOS和Android

Mobile平台上面每一个Engine实例启动的时候会为UI，GPU，IO Runner各自创建一个新的线程。
所有Engine实例共享同一个Platform Task Runner和Platform Thread。
从 Flutter 2.10 开始，可以使用任何一个有 Task Queue 的线程作为 Platform Task Runner，默认情况下还是使用应用的主线程作为 Platform Task Runner。
Platform Task Runner为什么一定要使用平台的主线程？因为Platform Task Runner的功能是要处理平台的消息，但是平台的API 绝大多数 都只能在主线程调用（尤其是UI相关的API以及触摸事件），所以Platform Task Runner运行所在的平台的线程必须是主线程。这也就是为什么全部实例共享同一个Platform Task Runner的根本原因。

Fuchsia

每一个Engine实例都为UI，GPU，IO，Platform Runner创建各自新的线程。

上面的线程模型介绍是为了我们后续实现整个应用的单例对象进行知识储备。

接下来，我们需要知道我们的代码默认运行在哪个线程上面。答案就是 UI Task Runner Thread（Dart Runner），运行 Dart Main Isolate 和应用主要的 Dart 代码。

那么为什么不直接复用 Platform Task Runner 呢？其实单独出现 Platform Task Runner 更多的是一种妥协的表现，这个线程不能长时间阻塞，否则会被系统杀死。如果直接复用这个线程，而不是使用其他线程非常容易导致 Platform Task Runner 过载，导致卡顿，另外很多系统API只能通过系统的主线程调用，因此这个 Platform Task Runner 主要用于虚拟机的初始化，虚拟机与系统通信等任务。

对于原生的 Flutter 应用（完全新建的纯 Flutter 工程）来说，整个应用只有一个 Flutter Engine，那么实现全局单例对象就比较简单，只要在代码中声明单例对象，当其他的Isolate需要访问单例对象的时候，与 Dart Main Isolate 通信即可实现对单例对象的访问。

对于通过 集成到现有应用（Add-to-app） 的方式，集成到已经存在的应用的情况来说，则需要分两种情况考虑，如果使用全局共享同一个 Flutter Engine 的方式来说，与原生Flutter 应用的区别不大。

但是当使用多 Flutter Engine 的方式来说，则比较复杂。

首先我们知道在 iOS和Android 平台上，所有Engine实例共享同一个Platform Task Runner和Platform Thread。也就是说在 iOS和Android 平台上，不管初始化多少个引擎实例，都有且只有一个相同的 Platform Task Runner 。因此，原理上只要是 Platform Task Runner 线程中实现一个全局或静态对象，然后通过 Platform Task Runner 创建其他线程（isolate），需要操作单例对象的时候，通过 Platform Task Runner ，就可以在 iOS和Android 平台上实现整个应用全局单例的效果。

但是很遗憾的是，我们没办法直接指定某段代码必须执行在 Platform Task Runner 上。因此，对于多线程安全的全局单例可以使用平台相关代码，在平台侧实现，然后使用平台相关API进行通信的方式来实现，这样有点类似于服务器上使用 Redis 进行数据存储的逻辑。

参考链接

Flutter 2.8.1本地化/国际化应用程序名称

Flutter 多国语言支持，参考 Flutter 2.8.1/Android Studio Bumblebee 2021.1.1多国语支持配置和使用

本地化/国际化应用程序名称 Android

系统与开发环境 macOS Big Sur 11.6.3/Android Studio Bumblebee 2021.1.1

Android下本地化应用程序名比较简单，只需要修改 AndroidManifest.xml 里的 application 标签下的 android:label 即可，如下图：

继续阅读Flutter 2.8.1本地化/国际化应用程序名称

Flutter项目中的pubspec.lock文件是什么？

每次我们运行一个新的 Flutter 项目并运行它时，我们都会看到一条消息：

"flutter pub get" in a_flutter_project...

1	"flutter pub get" in a_flutter_project...

问题是：当我们获得新的依赖项时会发生什么？

正如我们在上一篇文章中看到的《深入研究 Flutter Pubspec.yaml 文件》我们有不同的方法来向项目添加依赖项，但我们还没有讨论的一件事是为什么我们有时会添加插入^符号在我们的依赖版本之前：

# ...
  flutter_bloc: ^7.0.1

1 2	# ... flutter_bloc: ^7.0.1

这个符号有什么作用？它与pubspec.lock文件有什么关系？

灵活的依赖版本

正如Dart官方文档中所见，有几种不同的方式来定义包的版本：

any 或为空 - 这将导致包版本被定义为最新版本或确定相对于其他包约束应该使用哪个版本
<, >, <=, >= - 允许我们选择更低、更高、更低且等于或更高且等于规定版本的版本

但是，如果我们想要有灵活性和一些稳定性的保证，我们应该考虑使用插入^符号。如文档中所定义：

^version 表示/保证向后兼容指定版本的所有版本的范围。

因此，遵循语义版本指南（其中1.2.3是Major 1、Minor 2 和Patch 3），这意味着：

对于没有主要版本的依赖项，例如0.12.3和0.0.2-> 插入符号将查找包含在同一次要版本中的依赖项。所以^0.12.3会满足所有版本>= 0.12.3 < 0.13.0。
对于具有主要版本的依赖项，例如1.2.3，插入符号将查找包含在同一主要版本中的依赖项。所以^1.2.3会满足所有版本：>=1.2.3 <2.0.0

理论上（因为在实践中一些库可以打破这个规则），我们不会有从to或 from to 的破坏性更改，这就是为什么 Dart 冒昧地为我们升级这些版本。0.12.30.12.61.2.31.6.90

现在，这引出了两个不同的问题：

Dart 什么时候更新我们的依赖版本？
它如何为项目选择合适的版本？
在哪里可以找到与应用程序一起使用的特定版本？

要回答这些问题，我们必须了解什么是pubspec.lock文件。

pubspec.lock文件的剖析

与其尝试从整体上查看文件，不如换一种方式——我们创建一个新项目，提交它，然后添加一个新的依赖项：

dependencies:
  #...
  version_banner: ^0.2.0

dependencies:

#...

version_banner: ^0.2.0

之后，我们运行flutter pub get并查看pubspec.lock文件的差异内容：

diff --git a/pubspec.lock b/pubspec.lock
index 640db00..7d62228 100644
--- a/pubspec.lock
+++ b/pubspec.lock
@@ -81,6 +81,13 @@ packages:
       url: "https://pub.dartlang.org"
     source: hosted
     version: "1.3.0"
+  package_info:
+    dependency: transitive
+    description:
+      name: package_info
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "0.4.3+4"
   path:
     dependency: transitive
     description:
@@ -149,5 +156,13 @@ packages:
       url: "https://pub.dartlang.org"
     source: hosted
     version: "2.1.0"
+  version_banner:
+    dependency: "direct main"
+    description:
+      name: version_banner
+      url: "https://pub.dartlang.org"
+    source: hosted
+    version: "0.2.1"
 sdks:
   dart: ">=2.12.0 <3.0.0"
+  flutter: ">=1.12.13+hotfix.5"

diff --git a/pubspec.lock b/pubspec.lock

index 640db00..7d62228 100644

--- a/pubspec.lock

+++ b/pubspec.lock

@@ -81,6 +81,13 @@ packages:

url: "https://pub.dartlang.org"

source: hosted

version: "1.3.0"

+ package_info:

+ dependency: transitive

+ description:

+ name: package_info

+ url: "https://pub.dartlang.org"

+ source: hosted

+ version: "0.4.3+4"

path:

dependency: transitive

description:

@@ -149,5 +156,13 @@ packages:

url: "https://pub.dartlang.org"

source: hosted

version: "2.1.0"

+ version_banner:

+ dependency: "direct main"

+ description:

+ name: version_banner

+ url: "https://pub.dartlang.org"

+ source: hosted

+ version: "0.2.1"

sdks:

dart: ">=2.12.0 <3.0.0"

+ flutter: ">=1.12.13+hotfix.5"

我们一点一点来分析一下：

version_banner:
  dependency: "direct main"
  description:
    name: version_banner
    url: "https://pub.dartlang.org"
  source: hosted
  version: "0.2.1"

version_banner:

dependency: "direct main"

description:

url: "https://pub.dartlang.org"

source: hosted

version: "0.2.1"

在顶部，我们有库名称定义，在本例中为version_banner；
接着是dependency类型，它告诉我们它是一个direct依赖项，即我们通过pubspec.yaml文件添加的，还是一个transitive依赖项（如package_info锁定文件中的依赖项所示），它是一个依赖项的依赖项；
在description将相关的依赖性的类型的其他信息（GIT，本地或托管），无论是路径依赖，在git的承诺散列和URL存储库，或托管依赖的URL，在这种情况下， , pub.dev;
source告诉我们如何将依赖项添加到项目中。在本例中，我们通过 pub.dev（托管）添加它，但我们也可以使用sourceaspath或git;
最后，version将告诉我们我们正在使用的具体版本是什么。

如果我们仔细查看version，我们会发现虽然我们在pubspec.yamlversion 中定义了^0.2.0，但从锁定文件中解析出来的版本是0.2.1，这意味着 Dart 能够接受并使用最新版本的库，尊重它的次要版本。

为什么我们应该使用`^`

如果我们只使用一个依赖，使用的好处^只是让我们拥有最新最好的版本。然而，^在我们的依赖项中使用还有另一个很好的理由——它允许 Dart 足够灵活地选择一个与所有瞬态（或依赖项的依赖项）依赖项一致的依赖项版本。

想象一下以下场景 - 您http在应用程序中使用最新版本的包 - http: 0.13.0. 但是，您还使用了另一个名为 library_b 的库，它也依赖于http，但它使用的是更新版本！http: 0.13.3.

name: app_a

# ...
dependencies:
  library_b:  
    path: ../library_b

  http: 0.13.0

# ...

dependencies:

library_b:

path: ../library_b

http: 0.13.0

name: library_b
version: 0.0.1
# ...
dependencies:
  http: 0.13.3

version: 0.0.1

# ...

dependencies:

http: 0.13.3

那么如果我们选择使用确切的版本会发生什么http: 0.13.3？

➜  app_a flutter pub get
Running "flutter pub get" in app_a...                                                     
Because app_a depends on library_b from path which depends on http 0.13.3, http 0.13.3 is required.
So, because app_a depends on http 0.13.0, version solving failed.
pub get failed (1; So, because app_a depends
on http 0.13.0, version solving failed.)

➜ app_a flutter pub get

Running "flutter pub get" in app_a...

Because app_a depends on library_b from path which depends on http 0.13.3, http 0.13.3 is required.

So, because app_a depends on http 0.13.0, version solving failed.

pub get failed (1; So, because app_a depends

on http 0.13.0, version solving failed.)

由于我们使用的是硬依赖版本，Dart 将无法找到同时满足这两个约束的版本。但是如果我们添加^到应用程序的依赖项中呢？从理论上讲，这意味着应用程序会说“我可以有一个灵活的 http 版本，所以找到一个既满足又不引起冲突的版本”。

name: app_a

# ...
dependencies:
  library_b:  
    path: ../library_b

  http: ^0.13.3

# ...

dependencies:

library_b:

path: ../library_b

http: ^0.13.3

就这样，我们运行flutter pub get命令：

➜  app_a flutter pub get
Running "flutter pub get" in app_a...

1 2	➜ app_a flutter pub get Running "flutter pub get" in app_a...

查看pubspec.lock应用程序的文件，我们看到它现在使用更新版本0.13.3：

http:
    dependency: "direct main"
    description:
      name: http
      url: "https://pub.dartlang.org"
    source: hosted
    version: "0.13.3"

http:

dependency: "direct main"

description:

url: "https://pub.dartlang.org"

source: hosted

version: "0.13.3"

但是，如果版本不同会发生什么？让我们看看http应用程序版本高于库版本的情况：

name: app_a

# ...
dependencies:
  library_b:  
    path: ../library_b

  http: ^0.13.3

# ...

dependencies:

library_b:

path: ../library_b

http: ^0.13.3

name: library_b
version: 0.0.1
# ...
dependencies:
  http: 0.13.0

version: 0.0.1

# ...

dependencies:

http: 0.13.0

该^符号只能找到等于或高于我们声明的版本的版本，这意味着如果我们运行，flutter pub get我们将看到以下错误消息：

➜  app_a flutter pub get
Running "flutter pub get" in app_a...                                                     Because app_a depends on library_b from path which depends on http 0.13.0, http 0.13.0 is required.
Running "flutter pub get" in app_a...                                                     So, because app_a depends on http ^0.13.3, version solving failed.
Running "flutter pub get" in app_a...                                   
pub get failed (1; So, because app_a depends
on http ^0.13.3, version solving failed.)

➜ app_a flutter pub get

Running "flutter pub get" in app_a... Because app_a depends on library_b from path which depends on http 0.13.0, http 0.13.0 is required.

Running "flutter pub get" in app_a... So, because app_a depends on http ^0.13.3, version solving failed.

Running "flutter pub get" in app_a...

pub get failed (1; So, because app_a depends

on http ^0.13.3, version solving failed.)

解决这个问题的一个唯一的办法就是让这两个库和应用程序依赖于一个^版本，让他们找到一个版本，同时满足。

如果我们无法^在我们正在使用的依赖项中添加表示法，我们总是可以dependency_overrides在我们的pubspec.yaml文件中使用 a ，正如我们在深入研究 Pubspec.yaml 文件中所讨论的那样。

升级我们的版本

因此，如果通过运行flutter pub get我们没有看到通过pubspec.lock文件对我们的包进行任何更新，那么我们如何更新我们的依赖项？

答案是使用flutter pub upgrade！

让我们以以下应用程序依赖项为例，并假设pubspec.lock文件使用相同的版本：

name: app_a

# ...
dependencies:
  http: ^0.13.0
  flutter_bloc: ^7.0.0

# ...

dependencies:

http: ^0.13.0

flutter_bloc: ^7.0.0

如果我们运行，flutter pub upgrade我们会看到所有依赖项都将具有更高版本，符合以下标准^：

➜  app_a git:(master) flutter pub upgrade
Resolving dependencies...
  bloc 7.0.0
  characters 1.1.0
  collection 1.15.0
  ffi 1.1.2
  file 6.1.2
  flutter 0.0.0 from sdk flutter
> flutter_bloc 7.1.0 (was 7.0.0)
> shared_preferences 2.0.6 (was 2.0.0)
  ...
Changed 2 dependencies!
1 package has newer versions incompatible with dependency constraints.
Try `flutter pub outdated` for more information.

➜ app_a git:(master) flutter pub upgrade

Resolving dependencies...

bloc 7.0.0

characters 1.1.0

collection 1.15.0

ffi 1.1.2

file 6.1.2

flutter 0.0.0 from sdk flutter

> flutter_bloc 7.1.0 (was 7.0.0)

> shared_preferences 2.0.6 (was 2.0.0)

...

Changed 2 dependencies!

1 package has newer versions incompatible with dependency constraints.

Try `flutter pub outdated` for more information.

通过查看差异，我们可以看到这些版本已更新到较新的版本：

@@ -47,7 +47,7 @@ packages:
       name: flutter_bloc
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "7.0.0"
+    version: "7.1.0"
   flutter_web_plugins:
     dependency: transitive
     description: flutter
@@ -136,7 +136,7 @@ packages:
       name: shared_preferences
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "2.0.0"
+    version: "2.0.6"
   shared_preferences_linux:
     dependency: transitive
     description:

@@ -47,7 +47,7 @@ packages:

url: "https://pub.dartlang.org"

source: hosted

- version: "7.0.0"

+ version: "7.1.0"

flutter_web_plugins:

dependency: transitive

description: flutter

@@ -136,7 +136,7 @@ packages:

url: "https://pub.dartlang.org"

source: hosted

- version: "2.0.0"

+ version: "2.0.6"

shared_preferences_linux:

dependency: transitive

description:

但是如果我们不想升级所有的依赖呢？如果我们只想测试特定包的最新版本怎么办？幸运的是，该upgrade命令允许我们使用flutter pub upgrade <package_name>.

让我们通过使用来测试它flutter pub upgrade shared_preferences：

➜  app_a git:(master) flutter pub upgrade shared_preferences       
Resolving dependencies...
  bloc 7.0.0
  characters 1.1.0
  collection 1.15.0
  ffi 1.1.2
  file 6.1.2
  flutter 0.0.0 from sdk flutter
  flutter_bloc 7.0.0 (7.1.0 available)
  > shared_preferences 2.0.6 (was 2.0.0)
    ...
Changed 1 dependency!
2 packages have newer versions incompatible with dependency constraints.
Try `flutter pub outdated` for more information.

➜ app_a git:(master) flutter pub upgrade shared_preferences

Resolving dependencies...

bloc 7.0.0

characters 1.1.0

collection 1.15.0

ffi 1.1.2

file 6.1.2

flutter 0.0.0 from sdk flutter

flutter_bloc 7.0.0 (7.1.0 available)

> shared_preferences 2.0.6 (was 2.0.0)

...

Changed 1 dependency!

2 packages have newer versions incompatible with dependency constraints.

Try `flutter pub outdated` for more information.

正如我们所看到的，命令行告诉我们，虽然有一个更新的版本可用于flutter_bloc，但它没有被应用。我们可以通过查看差异来验证这一点：

@@ -136,7 +136,7 @@ packages:
       name: shared_preferences
       url: "https://pub.dartlang.org"
     source: hosted
-    version: "2.0.0"
+    version: "2.0.6"
   shared_preferences_linux:
     dependency: transitive
     description:

@@ -136,7 +136,7 @@ packages:

url: "https://pub.dartlang.org"

source: hosted

- version: "2.0.0"

+ version: "2.0.6"

shared_preferences_linux:

dependency: transitive

description:

查看flutter pub upgrade命令的最后一行，我们看到它提到了该flutter pub outdated命令。如果我们希望pubspec.yaml直接更新我们的文件，此命令可用于检查我们软件包的所有最新和兼容版本：

➜  app_a git:(master) ✗ flutter pub outdated
Showing outdated packages.
[*] indicates versions that are not the latest available.

Package Name        Current  Upgradable  Resolvable  Latest  

direct dependencies:
flutter_bloc        *7.0.0   7.1.0       7.1.0       7.1.0   
shared_preferences  *2.0.0   2.0.6       2.0.6       2.0.6   

transitive dependencies:
meta                *1.3.0   *1.3.0      *1.3.0      1.7.0   

2 upgradable dependencies are locked (in pubspec.lock) to older versions.
To update these dependencies, use `flutter pub upgrade`.

➜ app_a git:(master) ✗ flutter pub outdated

Showing outdated packages.

[*] indicates versions that are not the latest available.

Package Name Current Upgradable Resolvable Latest

direct dependencies:

flutter_bloc *7.0.0 7.1.0 7.1.0 7.1.0

shared_preferences *2.0.0 2.0.6 2.0.6 2.0.6

transitive dependencies:

meta *1.3.0 *1.3.0 *1.3.0 1.7.0

2 upgradable dependencies are locked (in pubspec.lock) to older versions.

To update these dependencies, use `flutter pub upgrade`.

锁文件在应用中的重要性

现在我们可能会问：为什么有一个锁文件这么重要？

答案很简单：

如果我们正在开发一个应用程序，该lock文件保证每个有权访问该项目的人都能够使用我们正在使用的相同版本的库来运行它。它是我们使用的真实版本的“真相来源”。

这意味着即使我们使用^符号，我们也不会在不同机器上有相同依赖项的不同解析版本，这使得与其他开发人员并行开发项目变得更容易。

但是，如果我们查看Dart 官方文档中的What not to commit，我们会看到不应提交pubspec.lock文件：

不要将库包的锁文件检查到源代码管理中，因为库应该支持一系列依赖版本。库包的直接依赖项的版本约束应尽可能宽，同时仍确保依赖项将与测试的版本兼容。

词汇表

结论

了解这个pubspec.lock文件已经很长时间了，但我们已经成功了

我们现在可以清楚地看到它的重要性——有一种明确的方法来查明我们的应用程序的依赖关系。

此外，我们看到了为什么^在声明依赖项时应该考虑使用该符号 - 它使我们更加灵活，具有更少的依赖项错误，并尝试我们正在使用的库的更新版本。

但是，在本文中，我们只探讨了使用 pub.dev 中的依赖项。如果我们考虑使用我们自己的git依赖项，我们将不仅知道version提交哈希，而且知道提交哈希。通过让我们回答一个非常重要的问题，这些信息可以为我们节省无数的调试时间 - 应用程序无法运行是因为我们没有使用每个库的最新版本吗？

在结束之前还有一件事需要考虑——正如Mark O'Sullivan指出的那样，^在其他技术中使用这种符号会导致Node.js 应用程序中的安全漏洞。您可以在 Chris Laughlin 的演讲中了解更多相关信息：您所有的包都属于我们——保护您的 npm 依赖项。

所以现在您知道如何使用pubspec.lock文件的力量——它将成为您项目的真实来源，以及一种共享和保持应用程序锁定在相同库版本中的方法。

参考链接

Flutter 项目中的pubspec.lock 文件是什么？

2024 年 11 月
一	二	三	四	五	六	日
				1	2	3
4	5	6	7	8	9	10
11	12	13	14	15	16	17
18	19	20	21	22	23	24
25	26	27	28	29	30

参考链接

Flutter 手势 - 跟随手指运动的小球

完整代码示例

序言

isolate 的作用

isolate 的局限性，为什么需要优化？

isolate 新特性

isolate中：exit 和 send 的区别及用法

isolate 组

实践：isolate 如何处理连续数据

参考链接

操作步骤

Flutter线程模型

Platform Task Runner

UI Task Runner Thread（Dart Runner）

Raster(GPU) Task Runner

IO Task Runner

各个平台目前默认Runner线程实现

iOS和Android

Fuchsia

参考链接

本地化/国际化应用程序名称 Android

灵活的依赖版本

pubspec.lock文件的剖析

为什么我们应该使用^

升级我们的版本

锁文件在应用中的重要性

结论

参考链接

为什么我们应该使用`^`