Flutter隔离执行插件easy_isolate的使用

简介

Easy Isolate 是一个用于在Flutter应用中轻松创建和管理独立线程（Isolates）的插件。它提供了一种抽象的方法来处理多线程，使得开发者可以更容易地在不同的线程中执行任务。以下是该插件的一些主要功能：

• Worker：负责启动新的线程，并允许主线程与新线程之间进行消息传递。
• Parallel：提供了run、map和foreach方法，可以在不同线程中执行函数、映射列表或遍历列表。

安装

在pubspec.yaml文件中添加依赖：

dependencies:
  easy_isolate: ^latest_version

使用方法

Worker

创建Worker并初始化

要开始使用Worker，你需要实例化一个Worker对象，并调用它的init方法。这个方法接受两个必须的参数：mainHandler和isolateHandler，以及可选的initialMessage、queueMode、errorHandler和exitHandler。

void main() async {
  final worker = Worker();
  await worker.init(mainHandler, isolateHandler, 
      initialMessage: 'firstMessage', queueMode: true);
}

void mainHandler(dynamic data, SendPort isolateSendPort) {
  // Handle messages from the isolate
}

void isolateHandler(dynamic data, SendPort mainSendPort, SendErrorFunction onSendError) {
  // Handle messages from the main thread
}

发送消息

可以通过worker.sendMessage或者mainHandler中的SendPort发送消息给Isolate。

// Using sendMessage
worker.sendMessage('Hello from main');

// Using SendPort in mainHandler
void mainHandler(dynamic data, SendPort isolateSendPort) {
  isolateSendPort.send('Hello from main');
}

接收消息

在isolateHandler中接收来自主线程的消息，并通过mainSendPort发送消息回主线程。

void isolateHandler(dynamic data, SendPort mainSendPort, SendErrorFunction onSendError) {
  print('Received: $data');
  mainSendPort.send('Hello from isolate');
}

错误和退出处理

可以设置errorHandler和exitHandler来处理错误和线程关闭事件。

void errorHandler(dynamic data) {
  print('Error occurred: $data');
}

void exitHandler(dynamic data) {
  print('Isolate is closing');
}

关闭Worker

调用worker.dispose()来关闭Worker，并清理资源。

await worker.dispose();

Parallel

Run

在不同的线程中执行一个函数。

Future<void> main() async {
  final result = await Parallel.run(isEven, entryValue: 1);
  print(result);
}

bool isEven({int? item}) {
  return item != null && item % 2 == 0;
}

Map

对列表中的每个元素应用一个函数，并返回一个新的列表。

Future<void> main() async {
  final result = await Parallel.map([1, 2, 3, 4], intToStringAdapter);
  print(result); // Should print all the values as a String
}

String intToStringAdapter(int i) {
  return i.toString();
}

Foreach

遍历列表中的每个元素，并执行一个函数。

Future<void> main() async {
  await Parallel.foreach(['test'], writeFile);
}

void writeFile(String name) {
  File(Directory.systemTemp.path + '/$name').createSync();
}

示例代码

以下是一个完整的示例，展示了如何在一个模拟文件下载器中使用easy_isolate插件。

import 'dart:async';
import 'dart:isolate';
import 'dart:math';

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

void main() {
  runApp(MyApp());
}

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Flutter Demo',
      theme: ThemeData(
        primarySwatch: Colors.blue,
      ),
      home: FileDownloaderScreen(),
    );
  }
}

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

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

class _FileDownloaderScreenState extends State<FileDownloaderScreen> {
  final List<DownloadItem> items =
      List.generate(100, (index) => DownloadItem('Item ${index + 1}'));

  final Map<DownloadItem, double> itemsDownloadProgress = {};

  void notifyProgress(DownloadItemProgressEvent event) {
    final item = event.item;
    if (itemsDownloadProgress.containsKey(item)) {
      itemsDownloadProgress.update(
        item,
        (value) => event.progress,
      );
    } else {
      itemsDownloadProgress.addAll({item: event.progress});
    }
    setState(() {});
  }

  bool hasOngoingDownload(DownloadItem item) {
    return itemsDownloadProgress.containsKey(item);
  }

  @override
  Widget build(BuildContext context) {
    final theme = Theme.of(context);
    return Scaffold(
      body: Column(
        children: [
          SizedBox(height: 20),
          Text('File downloader simulation', style: theme.textTheme.headline5),
          SizedBox(height: 20),
          Expanded(
            child: ListView.builder(
              itemCount: items.length,
              itemBuilder: (context, index) {
                final item = items[index];
                return Card(
                  child: Padding(
                    padding: EdgeInsets.all(8),
                    child: Row(
                      children: [
                        Text(item.name),
                        Spacer(),
                        Text('${item.size}mb'),
                        SizedBox(width: 10),
                        if (hasOngoingDownload(item))
                          SizedBox(
                            height: 20,
                            width: 20,
                            child: CircularProgressIndicator(
                              value: itemsDownloadProgress[item],
                            ),
                          )
                        else ...[
                          IconButton(
                            icon: Icon(Icons.download),
                            onPressed: () => FileDownloaderWorker(
                              item: item,
                              onNotifyProgress: notifyProgress,
                            ).init(),
                          ),
                        ]
                      ],
                    ),
                  ),
                );
              },
            ),
          ),
        ],
      ),
    );
  }
}

class DownloadItem {
  DownloadItem(this.name) : size = Random().nextInt(50);

  final String name;
  final int size;

  @override
  bool operator ==(Object other) =>
      identical(this, other) ||
      (other is DownloadItem &&
          runtimeType == other.runtimeType &&
          name == other.name &&
          size == other.size);

  @override
  int get hashCode => name.hashCode ^ size.hashCode;
}

class FileDownloaderWorker {
  FileDownloaderWorker({required this.onNotifyProgress, required this.item});

  final Function(DownloadItemProgressEvent event) onNotifyProgress;
  final DownloadItem item;
  final worker = Worker();

  Future<void> init() async {
    await worker.init(
      mainMessageHandler,
      isolateMessageHandler,
      errorHandler: print,
    );
    worker.sendMessage(DownloadItemEvent(item));
  }

  void mainMessageHandler(dynamic data, SendPort isolateSendPort) {
    if (data is DownloadItemProgressEvent) {
      onNotifyProgress(data);
    }
  }

  static isolateMessageHandler(
      dynamic data, SendPort mainSendPort, SendErrorFunction sendError) async {
    if (data is DownloadItemEvent) {
      final fragmentTime = 1 / data.item.size;
      double progress = 0;
      Timer.periodic(
        Duration(seconds: 1),
        (timer) {
          if (progress < 1) {
            progress += fragmentTime;
            mainSendPort.send(DownloadItemProgressEvent(data.item, progress));
          } else {
            timer.cancel();
          }
        },
      );
    }
  }
}

class DownloadItemEvent {
  DownloadItemEvent(this.item);

  final DownloadItem item;
}

class DownloadItemProgressEvent {
  DownloadItemProgressEvent(this.item, this.progress);

  final DownloadItem item;
  final double progress;
}

通过以上代码，你可以在Flutter应用中实现一个多线程的文件下载模拟器，每个下载任务都在单独的线程中运行，确保UI保持流畅。