<li id="fw3su"></li>
  • <li id="fw3su"></li>
  • <div id="fw3su"><tr id="fw3su"></tr></div>
    <dl id="fw3su"></dl>
  • <div id="fw3su"><tr id="fw3su"></tr></div>
  • <sup id="fw3su"></sup>
    <progress id="fw3su"></progress><div id="fw3su"><tr id="fw3su"></tr></div><input id="fw3su"><ins id="fw3su"></ins></input>

    深入理解Flutter多线程

    该文章属于 <简书 刘小壮=""> 原创,转载请注明:

    <简书 刘小壮=""> https://www.jianshu.com/p/54da18ed1a9e

    Flutter默认是单线程任务处理的,如果不开启新的线程,任务默认在主线程中处理。

    ?#24405;?#38431;列

    和iOS应用很像,在Dart的线程中也存在?#24405;?#24490;环和消息队列的概念,但在Dart中线程叫做isolate。应用程序启动后,开始执行main函数并运行main isolate。

    每个isolate包含一个?#24405;?#24490;环以及两个?#24405;?#38431;列,event loop?#24405;?#24490;环,以及event queue和microtask queue?#24405;?#38431;列,event和microtask队列有点类似iOS的source0和source1。

    • event queue:负责处理I/O?#24405;?#32472;制?#24405;?#25163;势?#24405;?#25509;收其他isolate消息等外部?#24405;?/p>

    • microtask queue:可以自己向isolate内部添加?#24405;录?#30340;优先级比event queue高。

    ?#24405;?#38431;列

    这两个队列也是有优先级的,当isolate开始执行后,会先处理microtask的?#24405;?#24403;microtask队列中没有?#24405;?#21518;,才会处理event队列中的?#24405;?#24182;按照这个顺序反复执?#23567;?#20294;需要注意的是,当执行microtask?#24405;?#26102;,会阻塞event队列的?#24405;?#25191;行,这样就会导致渲染、手势响应等event?#24405;?#21709;应延时。为了保证渲染和手势响应,应该尽量将耗时操作放在event队列?#23567;?/p>

    async、await

    在异步调用中有三个关键词,async、await、Future,其中async和await需要一起使用。在Dart中可以通过async和await进行异步操作,async表示开启一个异步操作,也可以返回一个Future结果。如果没有返回值,则默认返回一个返回值为null的Future。

    async、await本质上就是Dart对异步操作的一个语法糖,可以减少异步调用的嵌套调用,并且由async修饰后返回一个Future,外界可以以?#35789;?#35843;用的方式调用。这个语法是JS的ES7标准中推出的,Dart的设计和JS相同。

    下面封装了一个网络请求的异步操作,并且将请求后的Response类型的Future返回给外界,外界可以通过await调用这个请求,并获取返回数据。从代码中可以看到,即便直接返回一个字符串,Dart?#19981;?#23545;其进行包装并成为一个Future。

    Future
    <response>
      dataReqeust() async {
        String requestURL = 'https://jsonplaceholder.typicode.com/posts';
        Client client = Client();
        Future
     <response>
       response = client.get(requestURL);
        return response;
    }
    
    Future
      <string>
        loadData() async {
        Response response = await dataReqeust();
        return response.body;
    }
      </string>
     </response>
    </response>

    在代码示例中,执行到loadData方法时,会同步进入方法内部进行执行,当执行到await时就会停止async内部的执行,从而继续执行外面的代码。当await有返回后,会继续从await的位置继续执?#23567;?#25152;以await的操作,不会影响后面代码的执?#23567;?/p>

    下面是一个代码示例,通过async开启一个异步操作,通过await等待请求或其他操作的执行,并接收返回值。当数据发生改变时,调用setState方法并更新数据源,Flutter会更新对应的Widget节点视图。

    class _SampleAppPageState extends State
    <sampleapppage>
      {
      List widgets = [];
      
      @override
      void initState() {
        super.initState();
        loadData();
      }
      
      loadData() async {
        String dataURL = "https://jsonplaceholder.typicode.com/posts";
        http.Response response = await http.get(dataURL);
        setState(() {
          widgets = json.decode(response.body);
        });
      }
    }
    </sampleapppage>

    Future

    Future就是延时操作的一个封装,可以将异步任务封装为Future对象。获取到Future对象后,最简单的方法就是用await修饰,并等待返回结果继续向下执?#23567;?#27491;如上面async、await中讲到的,使用await修饰时需要配合async一起使用。

    在Dart中,和时间相关的操作基本都和Future有关,例如延时操作、异步操作等。下面是一个很简单的延时操作,通过Future的delayed方法实现。

    loadData() {
        // DateTime.now(),获取当前时间
        DateTime now = DateTime.now();
        print('request begin $now');
        Future.delayed(Duration(seconds: 1), (){
          now = DateTime.now();
          print('request response $now');
        });
    }

    Dart还支持对Future的?#35789;?#35843;用,通过追加一个或多个then方法?#35789;?#29616;,这个特性非常实用。例如一个延时操作完成后,会调用then方法,并且可以传递一个参数给then。调用方式是?#35789;?#35843;用,也就代表可以进行很多层的处理。这有点类似于iOS的RAC框架,?#35789;?#35843;用进行信号处理。

    Future.delayed(Duration(seconds: 1), (){
      int age = 18;
      return age;
    }).then((onValue){
      onValue++;
      print('age $onValue');
    });

    协程

    如果想要了解async、await的原理,就要先了解协程的概念,async、await本质上就是协程的一种语法糖。协程,也叫作coroutine,是一种比线程更小的单元。如果从单元大小来说,基本可以理解为进程->线程->协程。

    任务调度

    在弄懂协程之前,首先要明白并发和并行的概念,并发指的是?#19978;?#32479;来管理多个IO的切换,并交由CPU去处理。并行指的是多核CPU在同一时间里执行多个任务。

    并发的实现由非阻塞操作+?#24405;?#36890;知来完成,?#24405;?#36890;知也叫做“中断”。操作过程分为两种,一种是CPU对IO进行操作,在操作完成后发起中断告诉IO操作完成。另一种是IO发起中断,告诉CPU可以进行操作。

    线程本质上也是依赖于中断来进行调度的,线程还有一种叫做“阻塞式中断?#20445;?#23601;是在执行IO操作时将线程阻塞,等待执行完成后再继续执?#23567;?#20294;线程的消耗是很大的,并不适合大量并发操作的处理,而通过单线程并发可以进行大量并发操作。当多核CPU出现后,单个线程就无法很好的利用多核CPU的优势了,所以又引入了线程池的概念,通过线程池来管理大量线程。

    协程

    在程序执行过程中,离开当前的调用位置有两种方式,继续调用其他函数和return返回离开当前函数。但是执行return时,当前函数在调用栈中的局部变量、形参等状态则会被销毁。

    协程分为无线协程和有线协程,无线协程在离开当前调用位置时,会将当前变量放在堆区,当再次回到当前位置时,还会继续从堆区中获取到变量。所以,一般在执行当前函数时就会将变量直接分配到堆区,而async、await就属于无线协程的一种。有线协程则会将变量继续保存在栈区,在回到指针指向的离开位置时,会继续从栈中取出调用。

    async、await原理

    以async、await为例,协程在执行时,执行到async则表示进入一个协程,会同步执行async的代码块。async的代码块本质上也相当于一个函数,并且有自己的上下文环境。当执行到await时,则表示有任务需要等待,CPU则去调度执行其他IO,也就是后面的代码或其他协程代码。过一段时间CPU就会轮训一次,看某个协程是否任务已经处理完成,有返回结果可以被继续执行,如果可以被继续执行的话,则会沿着上次离开时指针指向的位置继续执行,也就是await标志的位置。

    由于并没有开启新的线程,只是进行IO中断改变CPU调度,所以网络请求这样的异步操作可以使用async、await,但如果是执行大量耗时同步操作的话,应该使用isolate开辟新的线程去执?#23567;?/p>

    如果用协程和iOS的dispatch_async进行对比,可以发现二者是比较相似的。从结构定义来看,协程需要将当前await的代码块相关的变量进行存储,dispatch_async也可以通过block?#35789;?#29616;临时变量的存储能力。

    我之前还在想一个问题,苹果为什么不引入协程的特性呢?后来想了一下,await和dispatch_async都可以简单理解为异步操作,OC的线程是基于Runloop实现的,Dart本质上也是有?#24405;?#24490;环的,而且二者都有自己的?#24405;?#38431;列,只是队列数量和分类不同。

    我觉得当执行到await时,保存当前的上下文,并将当前位置标记为待处理任务,用一个指针指向当前位置,并将待处理任务放入当前isolate的队列?#23567;?#22312;每个?#24405;?#24490;环时都去询?#25910;?#20010;任务,如果需要进行处理,就恢复上下文进行任务处理。

    Promise

    这里想提一下JS里的Promise语法,在iOS中会出现很多if判断或者其他的嵌套调用,而Promise可以把之前横向的嵌套调用,改成纵向?#35789;?#35843;用。如果能把Promise引入到OC里,可以让代码看起来更简洁,直观。

    isolate

    isolate是Dart平台对线程的实现方案,但?#25512;?#36890;Thread不同的是,isolate拥有独立的内存,isolate由线程和独立内存构成。正是由于isolate线程之间的内存不共享,所以isolate线程之间并不存在资源抢夺的问题,所以也不需要锁。

    通过isolate可以很好的利用多核CPU,来进行大量耗时任务的处理。isolate线程之间的通信主要通过port来进行,这个port消息传递的过程是异步的。通过Dart源码也可以看出,实例化一个isolate的过程包括,实例化isolate结构体、在堆中分配线程内存、?#28210;胮ort等过程。

    isolate看起来其实和进程比较相似,之前请教阿里架构师宗心问题时,宗心也说过“isolate的整体模型我自己的理解其实更像进程,而async、await更像是线程”。如果对比一下isolate和进程的定义,会发现确实isolate很像是进程。

    代码示例

    下面是一个isolate的例子,例子中新创建了一个isolate,并且绑定了一个方法进行网络请求和数据解析的处理,并通过port将处理好的数据返回给调用方。

    loadData() async {
        // 通过spawn新建一个isolate,并绑定静态方法
        ReceivePort receivePort =ReceivePort();
        await Isolate.spawn(dataLoader, receivePort.sendPort);
        
        // 获取新isolate的监听port
        SendPort sendPort = await receivePort.first;
        // 调用sendReceive自定义方法
        List dataList = await sendReceive(sendPort, 'https://jsonplaceholder.typicode.com/posts');
        print('dataList $dataList');
    }
    
    // isolate的绑定方法
    static dataLoader(SendPort sendPort) async{
        // 创建监听port,并将sendPort传给外界用来调用
        ReceivePort receivePort =ReceivePort();
        sendPort.send(receivePort.sendPort);
        
        // 监听外界调用
        await for (var msg in receivePort) {
          String requestURL =msg[0];
          SendPort callbackPort =msg[1];
        
          Client client = Client();
          Response response = await client.get(requestURL);
          List dataList = json.decode(response.body);
          // 回调返回值给调用者
          callbackPort.send(dataList);
        }    
    }
    
    // 创建自己的监听port,并且向新isolate发送消息
    Future sendReceive(SendPort sendPort, String url) {
        ReceivePort receivePort =ReceivePort();
        sendPort.send([url, receivePort.sendPort]);
        // 接收到返回值,返回给调用者
        return receivePort.first;
    }

    isolate和iOS中的线程还不太一样,isolate的线程更偏底层。当生成一个isolate后,其内存是各自独立的,相互之间并不能进行访问。但isolate提供了基于port的消息机制,通过建立通信双方的sendPort和receiveport,进行相互的消息传递,在Dart中叫做消息传递。

    从上面例子中可以看出,在进行isolate消息传递的过程中,本质上就是进行port的传递。将port传递给其他isolate,其他isolate通过port拿到sendPort,向调用方发送消息来进行相互的消息传递。

    Embedder

    正如其名,Embedder是一个嵌入层,将Flutter嵌入到各个平台上。Embedder负责?#27573;?#21253;括原生平台插件、线程管理、?#24405;?#24490;环等。

    Flutter System Overriew

    Embedder中存在四个Runner,四个Runner?#30452;?#22914;下。其中每个Flutter Engine各自对应一个UI Runner、GPU Runner、IO Runner,但所有Engine共享一个Platform Runner。

    Embedder

    Runner和isolate并不是一码事,彼此相互独立。以iOS平台为例,Runner的实现就是CFRunLoop,以一个?#24405;?#24490;环的方式不断处理任务。并且Runner不只处理Engine的任务,还有Native Plugin带来的原生平台的任务。而isolate则由Dart VM进行管理,和原生平台线程并无关系。

    Platform Runner

    Platform Runner和iOS平台的Main Thread非常相似,在Flutter中除耗时操作外,所有任务都应该放在Platform中,Flutter中的很多API并不是线程安全的,放在其他线程中可能会导致一些bug。

    但例如IO之类的耗时操作,应该放在其他线程中完成,否则会影响Platform的正常执行,甚至于被watchdog干掉。但需要注意的是,由于Embedder Runner的机制,Platform被阻塞后并不会导致页面卡顿。

    不只是Flutter Engine的代码在Platform中执行,Native Plugin的任务?#19981;?#27966;发到Platform中执?#23567;J导?#19978;,在原生侧的代码运行在Platform Runner中,而Flutter侧的代码运行在Root Isolate中,如果在Platform中执行耗时代码,则会卡原生平台的主线程。

    UI Runner

    UI Runner负责为Flutter Engine执行Root Isolate的代码,除此之外,也处理来自Native Plugin的任务。Root Isolate为了处理自身?#24405;?#32465;定了很多函数方法。程序启动时,Flutter Engine会为Root绑定UI Runner的处理函数,使Root Isolate具备提交渲染帧的能力。

    当Root Isolate向Engine提交一次渲染帧时,Engine会等待下次vsync,当下次vsync到来时,由Root Isolate对Widgets进行布局操作,并生成页面的显示信息的描述,并将信息交给Engine去处理。

    由于对widgets进行layout并生成layer tree是UI Runner进行的,如果在UI Runner中进行大量耗时处理,会影响页面的显示,所以应该将耗时操作交给其他isolate处理,例如来自Native Plugin的?#24405;?/p>

    Rendering Pipeline.jpg

    GPU Runner

    GPU Runner并不直接负责渲染操作,其负责GPU相关的管理和调?#21462;?#24403;layer tree信息到来时,GPU Runner将其提交给指定的渲染平台,渲染平台是Skia?#28210;?#30340;,不同平台可能有不同的实现。

    GPU Runner相对比较独立,除了Embedder外其他线程均不可向其提交渲染信息。

    Graphics Pipeline

    IO Runner

    一些GPU Runner中比较耗时的操作,就放在IO Runner中进行处理,例如图片读取、解压、渲染等操作。但是只有GPU Runner才能对GPU提交渲染信息,为了保证IO Runner也具备这个能力,所以IO Runner会引用GPU Runner的context,这样就具备向GPU提交渲染信息的能力。

    我来评几句
    登录后评论

    已发表评论数()

    相关站点

    +订阅
    ?#35753;?#25991;章
    11选五