刘新修

fetch获取wasm模块实例

axios获取wasm模块实例

loadWebAssemblyModule.js 封装

centos 安装 Emscripten

Rust 是一种系统级编程语言，旨在提供高性能和内存安全，同时避免常见的编程错误。
由 Mozilla Research 推出，Rust 自推出以来因其独特的设计理念和强大的功能而在开发者社区中迅速获得了广泛的关注和采用。

安装命令：

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

分解说明：

curl：这是一个用于在命令行下传输数据的工具，支持多种协议（如 HTTP、HTTPS、FTP 等）。

--proto '=https'：指定只允许使用 HTTPS 协议进行传输，确保数据传输的安全性。

--tlsv1.2：强制 curl 使用 TLS 1.2 协议，这是一种安全的传输层协议。

-s：静默模式（silent），在执行过程中不会显示进度条或错误信息。

-Sf：

-S：当使用 -s（静默模式）时，-S 可以让 curl 在发生错误时仍然显示错误信息。

-f：如果服务器返回一个错误状态码（如 404），curl 会失败并返回一个错误，而不是输出错误页面的内容。

https://sh.rustup.rs：这是 Rust 官方提供的安装脚本的 URL。

| sh：管道符号（|）将前一个命令（curl）的输出传递给后一个命令（sh）。也就是说，下载的安装脚本将直接由 sh（shell）执行。

整体作用：

这个命令通过安全的 HTTPS 连接下载 Rust 的安装脚本，并立即在您的终端中执行该脚本，以便安装 Rust 编程语言及其工具链。

输出解释

逐行解释：

info: downloading installer

解释：安装程序正在下载过程中。

Welcome to Rust!

解释：欢迎使用 Rust！

接下来的几行

解释：这些行说明了安装过程将会下载和安装 Rust 官方编译器（rustc）以及其包管理器（Cargo）。

Rustup metadata and toolchains will be installed into the Rustup home directory, located at:

解释：Rustup 的元数据和工具链将被安装到指定的 Rustup 主目录中，默认路径为 /home/jjmczd/.rustup。您可以通过设置 RUSTUP_HOME 环境变量来修改此路径。

The Cargo home directory is located at:

解释：Cargo 的主目录位于 /home/jjmczd/.cargo。同样，您可以通过设置 CARGO_HOME 环境变量来修改此路径。

The cargo, rustc, rustup and other commands will be added to Cargo's bin directory, located at:

解释：cargo、rustc、rustup 以及其他相关命令将被添加到 Cargo 的 bin 目录中，即 /home/jjmczd/.cargo/bin。

This path will then be added to your PATH environment variable by modifying the profile files located at:

解释：安装程序会将上述 bin 目录路径添加到您的 PATH 环境变量中，这通过修改您的 shell 配置文件（如 /home/jjmczd/.profile 和 /home/jjmczd/.bashrc）来实现。这样，您可以在任何终端会话中直接运行 Rust 的命令。

You can uninstall at any time with rustup self uninstall and these changes will be reverted.

解释：如果您在任何时候想要卸载 Rust，可以运行 rustup self uninstall 命令，这将撤销所有安装的更改。

Current installation options:

解释：当前的安装选项如下：

default host triple: x86_64-unknown-linux-gnu

解释：默认的主机三元组（host triple）是 x86_64-unknown-linux-gnu，表示安装的是适用于 64 位 Linux 系统的 Rust 工具链。

default toolchain: stable (default)

解释：默认的工具链是 stable 版本，这是 Rust 的稳定版本，适合大多数用户和生产环境使用。

profile: default

解释：使用的是默认的安装配置文件，包含基本的组件和设置。

modify PATH variable: yes

解释：安装程序将修改您的 PATH 环境变量，以便您可以在终端中直接使用 Rust 的命令。

安装选项菜单：

 开发本地项目时，访问接口如果遇到类似net::ERR_FAILED、Error: Network Error、Preflight等情形，可排查下是否因浏览器自身所致。

用新版chrome（版本92+）跨域请求本地接口，比如http://192.168.xxx.xxx/token。

点击右上角红色警告按钮，提示如下：

大概意思：

一个站点从一个网络中请求一个资源，由于其用户的特权网络位置，它只能访问这个资源。这些请求将设备和服务器暴露给互联网，增加了跨站点请求伪造(CSRF)攻击和/或信息泄漏的风险。
为了降低这些风险，Chrome弃用从非安全上下文发起的对非公共子资源的请求，并将在Chrome 92中开始屏蔽它们(2021年7月)。
若要解决此问题，请将需要访问本地资源的网站迁移到HTTPS。如果目标资源不在本地主机上提供服务，那么它也必须通过HTTPS提供服务，以避免混合内容问题。
管理员可以使用企业策略的insecureprivatenetworkrequestallowed和InsecurePrivateNetworkRequestsAllowedForUrls在所有或某些网站上暂时禁用此限制。

其实还是跨域方面的问题，按照要求设置即可。最简单的方法是暂时禁用此功能，毕竟本地测试的项目，一般安全性都不需要太高。

地址栏输入：chrome://flags/，回车。搜索找到Block insecure private network requests，设置禁用（Disabled），然后重启浏览器即可

 我们在下载大文件时，通常会使用多线程下载的方式来加快下载速度。例如常用的多线程下载工具（Gopeed、Aria2、XDM等等），都是通过多线程下载技术充分利用了网络带宽，以提高下载速度。

那么多线程下载是怎么实现的呢？多个线程发送网络请求，是怎么做到同时下载一个文件呢？事实上，借助HTTP协议中的一些机制就可以实现了！

今天我们就通过使用Go语言为例，从了解HTTP请求相关的一些机制开始，实现一个多线程下载的示例。

1，多线程下载原理

事实上，多线程下载的原理很简单，主要的步骤如下：

• 获取待下载文件大小
• 每个线程下载文件的一部分
• 全部下载完成后，拼接为完整文件

实现这些步骤，就涉及到HTTP协议的下列相关机制。

(1) HEAD请求 - 只获取请求头

我们通常发送HTTP请求大多数是GET或者POST类型，发送请求后我们会立即获取响应体，浏览器则会根据响应体的类型来处理内容，例如返回的是text/html就会作为网页显示，返回image/png就会解码为图片等等，响应体的类型由响应头Content-Type标识。当我们下载文件时，事实上也是发送HTTP请求，只不过服务器返回的响应体就是文件本身了！其类型则是application/octet-stream，浏览器也知道这是个文件需要下载。

当然，文件作为响应体通常比起网页、图片要大得多，在多线程下载时，我们就要先获取文件的大小，而不是立即获取文件本身，这时我们就可以向服务器发起HEAD请求而不是GET请求。

服务器收到HEAD请求后，就只会返回对应的响应头，而不会返回响应体，这样我们就可以在下载文件之前，读取响应头中的Content-Length来先获取待下载文件大小。

(2) Range请求头 - 只获取部分响应体

知道了文件大小，我们就需要让每个线程只下载一部分文件，借助HTTP的Range请求头，就可以实现只让服务端返回响应体内容的一部分，而不是返回完整的响应体。

这里我们先来借助书籍《图解HTTP》中对Range请求头的讲解，来学习一下：

XML/HTML代码

1. Range: bytes=5001-10000  

那么服务端就只会返回响应体的第5001到第10000字节的内容部分，包含第5001和第10000字节，0表示响应体的第一个字节。

这样，在多个线程同时下载文件时，我们在每个线程的请求中使用Range请求头，就可以实现一个线程只下载文件的一部分了！

(3) 为什么多线程下载可以提升速度？

事实上，在我们客户端（下载文件的）和服务端双向网络通信情况都很好的情况下，使用单线程和多线程下载的速度是几乎没有差异的，也就是说能够跑满我们客户端的全部带宽，那么这种情况下我们使用单线程下载反而更能够节省硬件和网络资源。

但是在我们客户端和服务端之间网络波动较大的情况下，例如我们国内从Github下载文件的时候，就会发现多线程下载速度比单线程快得多，反之使用单线程完全无法充分利用我们的网络带宽。

这种现象事实上是因为TCP连接的慢启动机制导致的，众所周知HTTP是基于TCP的协议，每次我们建立HTTP连接时，包括下载文件，都是在传输层基于TCP协议进行传输。TCP慢启动机制是TCP 协议中一种拥塞控制的机制，目的是在开始数据传输时逐步探测网络的容量，避免瞬间发送大量数据而导致网络拥塞。慢启动不是字面意义上的“慢”，而是相对于立即使用最大带宽而言，它会逐渐增加传输速率。

慢启动机制的过程简要概括如下：

• 一开始建立连接：当一个新的TCP连接建立后，发送方并不知道当前网络的拥塞情况。因此，发送方不会马上发送大量数据，而是会使用慢启动机制来逐步增加数据传输的速率，在TCP中使用阻塞窗口cwnd来限制发送的数据量，也就是说一开始cwnd是非常小的
• 拥塞窗口增长：在建立连接后，每当接收到一个确认ACK包时，cwnd会指数级增长，直到达到网络的带宽限制或者某个拥塞控制的阈值（称为慢启动阈值ssthresh），这个过程会一直持续，直到发送方探测到网络出现了拥塞（比如丢包或者确认延迟变长），或者cwnd达到了某个预定义的慢启动阈值ssthresh
• 慢启动的终止：慢启动机制会在以下情况终止：
  • 达到慢启动阈值ssthresh：当拥塞窗口cwnd增长到慢启动阈值ssthresh时，慢启动机制停止，此时TCP会进入另一种拥塞控制机制，称为拥塞避免，这时cwnd增长变为线性而非指数级
  • 发生拥塞（如丢包或超时）：如果发送方检测到数据包丢失（例如没有收到确认），它会认为网络已经出现拥塞，此时ssthresh会被调整为当前cwnd的一半，然后cwnd会重置为1 MSS，重新进入慢启动阶段

可见TCP连接使用cwnd限制两者发送的数据量的大小，并逐步“试探”两者传输数据速率的上限并增加传输的数据量。

在我们下载文件时，事实上是服务端在向我们发送文件，如果网络波动较大、不稳定，TCP连接机会一直将cwnd限制在一个较小的值，在单位时间内，服务端也无法向我们发送更大的数据量。

此时，如果我们使用多线程下载，和服务端建立多个TCP连接，这样即使每个TCP连接的cwnd较小，所有TCP连接加起来传输的数据量仍然可以占满我们的带宽。

2，Go代码实现

知道了HTTP的上述几个机制，相信大家就知道如何实现一个简单的多线程下载了！我们可以总结主要步骤如下：

• 发送HEAD类型请求，通过Content-Length请求头获取待下载文件大小
• 根据给定的线程数量，结合待下载文件大小，确定每个线程下载的范围部分，也就是每个线程的Range请求头字节范围
• 启动所有线程，使得每个线程下载它们对应的部分文件，并等待全部线程下载完成
• 合并每个线程下载的部分为最终文件
• 清理每个线程下载的文件部分

这里分别设计下列类（结构体），用于存放多线程下载时的传入参数和状态量：

 

上述ShardTask类表示一个线程的下载任务，其中会完成一个分片（文件的一部分）的下载请求操作，它有如下作为参数的属性：

• Url 下载的文件地址
• Order 分片序号
• ShardFilePath 这个分片文件的保存路径
• RangeStart和RangeEnd 下载的文件起始范围和结束范围，用于设定Range请求头

此外，还有作为下载状态的属性：

• DownloadSize 下载任务进行时，这个线程已下载的文件部分大小
• TaskDone 这个线程的下载任务是否完成

该类的成员方法如下：

• DoShardGet 执行分片下载任务，在其中会根据RangeStart和RangeEnd设定对应的HTTP请求头，发送请求并下载对应的文件部分

然后就是ParallelGetTask类，表示一整个多线程下载任务，其中包含了一个多线程下载任务的参数和状态量，并且实现了多线程下载的每个步骤，它有如下作为参数的属性：

• Url 文件的下载链接
• FilePath 文件下载完成后的保存位置
• Concurrent 下载并发数，即同时下载的分片数量
• TempFolder 临时分片文件的保存文件夹

此外还有作为状态的属性：

• TotalSize 待下载文件的总大小
• ShardTaskList 存储所有分片任务对象指针的列表

该类中的方法主要是分片下载的一些步骤如下：

• getLength 发送HEAD请求获取Content-Length以获取文件大小，获取后将其设定到TotalSize属性
• allocateTask 根据给定的线程数和获取到的文件大小，计算每个线程下载的文件内容范围，并创建对应的ShardTask结构体放入ShardTaskList中
• downloadShard 为每一个ShardTask对象创建一个线程（Goroutine）并在新的线程中调用ShardTask对象的下载分片方法，以启动所有线程的下载任务，并通过sync.WaitGroup来等待全部线程完成
• mergeFile 下载完成后，合并每个分片为最终文件
• cleanShard 合并完成后，清理下载的每个分片文件
• printTotalProcess 这是一个附加的辅助方法，用于实时输出下载进度
• Run 启动整个多线程下载任务，该函数是暴露的公开函数，其中对上述每个步骤函数进行了组织，按顺序调用执行

下面，我们来看一下它们的代码实现。

(1) ShardTask - 一个线程的下载任务

C#代码

1. package model  
2.   
3. import (  
4.     "bufio"  
5.     "fmt"  
6.     "github.com/fatih/color"  
7.     "io"  
8.     "net/http"  
9.     "os"  
10.     "sync"  
11. )  
12.   
13. // 全局HTTP客户端  
14. var httpClient = http.Client{  
15.     Transport: &http.Transport{  
16.         // 关闭keep-alive确保一个线程就使用一个TCP连接  
17.         DisableKeepAlives: true,  
18.     },  
19. }  
20.   
21. // ShardTask 单个分片下载任务的任务参数和状态量  
22. type ShardTask struct {  
23.     // 下载链接  
24.     Url string  
25.     // 分片序号，从1开始  
26.     Order int  
27.     // 这个分片文件的路径  
28.     ShardFilePath string  
29.     // 分片的起始范围（字节，包含）  
30.     RangeStart int64  
31.     // 分片的结束范围（字节，包含）  
32.     RangeEnd int64  
33.     // 已下载的部分（字节）  
34.     DownloadSize int64  
35.     // 该任务是否完成  
36.     TaskDone bool  
37. }  
38.   
39. // NewShardTask 构造函数  
40. func NewShardTask(url string, order int, shardFilePath string, rangeStart int64, rangeEnd int64) *ShardTask {  
41.     return &ShardTask{  
42.         // 设定任务参数  
43.         Url:           url,  
44.         Order:         order,  
45.         ShardFilePath: shardFilePath,  
46.         RangeStart:    rangeStart,  
47.         RangeEnd:      rangeEnd,  
48.         // 初始化状态量  
49.         DownloadSize: 0,  
50.         TaskDone:     false,  
51.     }  
52. }  
53.   
54. // DoShardGet 开始下载这个分片（该方法在goroutine中执行）  
55. func (task *ShardTask) DoShardGet(waitGroup *sync.WaitGroup) {  
56.     // 创建文件  
57.     file, e := os.OpenFile(task.ShardFilePath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0755)  
58.     if e != nil {  
59.         color.Red("任务%d创建文件失败！", task.Order)  
60.         color.HiRed("%s", e)  
61.         return  
62.     }  
63.     // 准备请求  
64.     request, e := http.NewRequest("GET", task.Url, nil)  
65.     if e != nil {  
66.         color.Red("任务%d创建请求出错！", task.Order)  
67.         color.HiRed("%s", e)  
68.         return  
69.     }  
70.     // 设定请求头  
71.     request.Header.Set("Range", fmt.Sprintf("bytes=%d-%d", task.RangeStart, task.RangeEnd))  
72.     // 发送请求  
73.     response, e := httpClient.Do(request)  
74.     if e != nil {  
75.         color.Red("任务%d发送下载请求出错！", task.Order)  
76.         color.HiRed("%s", e)  
77.         return  
78.     }  
79.     // 读取请求体  
80.     body := response.Body  
81.     // 读取缓冲区  
82.     buffer := make([]byte, 8092)  
83.     // 准备写入文件  
84.     writer := bufio.NewWriter(file)  
85.     for {  
86.         // 读取一次内容至缓冲区  
87.         readSize, readError := body.Read(buffer)  
88.         if readError != nil {  
89.             // 如果读取完毕则退出循环  
90.             if readError == io.EOF {  
91.                 break  
92.             } else {  
93.                 color.Red("任务%d读取响应错误！", task.Order)  
94.                 color.HiRed("%s", readError)  
95.                 return  
96.             }  
97.         }  
98.         // 把缓冲区内容追加至文件  
99.         _, writeError := writer.Write(buffer[0:readSize])  
100.         if writeError != nil {  
101.             color.Red("任务%d写入文件时出现错误！", task.Order)  
102.             color.HiRed("%s", writeError)  
103.             return  
104.         }  
105.         _ = writer.Flush()  
106.         // 记录下载进度  
107.         task.DownloadSize += int64(readSize)  
108.     }  
109.     // 关闭全部资源  
110.     _ = body.Close()  
111.     _ = file.Close()  
112.     // 标记任务完成  
113.     task.TaskDone = true  
114.     // 使线程组中计数器-1  
115.     waitGroup.Done()  
116. }  

构造函数NewShardTask负责完成ShardTask的参数传入和状态量初始化，而DoShardGet方法实现了下载一个文件分片的完整步骤，从创建文件准备写入，到设定请求头，发出请求，最后读取响应体保存到文件。

此外，可见这里的http.Client对象中，我们将其DisableKeepAlives设为了true即关闭keep-alive，这是因为默认情况下Go语言的HTTP客户端会复用TCP连接，即使你多个线程发起请求，也会使用一个TCP连接进行。

而多线程下载需要每个线程持有一个单独的TCP连接来达到突破cwnd的限制，因此这里关闭keep-alive实现每个线程发起请求时，使用单独的TCP连接。

(2) ParallelGetTask - 一整个多线程下载任务

C#代码

1. package model  
2.   
3. import (  
4.     "bufio"  
5.     "fmt"  
6.     "gitee.com/swsk33/shard-download-demo/util"  
7.     "github.com/fatih/color"  
8.     "io"  
9.     "net/http"  
10.     "os"  
11.     "path/filepath"  
12.     "strconv"  
13.     "sync"  
14.     "time"  
15. )  
16.   
17. // ParallelGetTask 多线程下载任务类，存放一个多线程下载任务的参数和状态量  
18. type ParallelGetTask struct {  
19.     // 文件的下载链接  
20.     Url string  
21.     // 文件的最终保存位置  
22.     FilePath string  
23.     // 下载并发数  
24.     Concurrent int  
25.     // 下载的分片临时文件保存文件夹  
26.     TempFolder string  
27.     // 下载文件的总大小  
28.     TotalSize int64  
29.     // 全部的下载分片任务参数列表  
30.     ShardTaskList []*ShardTask  
31. }  
32.   
33. // NewParallelGetTask 构造函数  
34. func NewParallelGetTask(url string, filePath string, concurrent int, tempFolder string) *ParallelGetTask {  
35.     return &ParallelGetTask{  
36.         // 参数赋值  
37.         Url:        url,  
38.         FilePath:   filePath,  
39.         Concurrent: concurrent,  
40.         TempFolder: tempFolder,  
41.         // 初始化状态量  
42.         TotalSize:     0,  
43.         ShardTaskList: make([]*ShardTask, 0),  
44.     }  
45. }  
46.   
47. // 发送HEAD请求获取待下载文件的大小  
48. func (task *ParallelGetTask) getLength() error {  
49.     // 发送请求  
50.     response, e := http.Head(task.Url)  
51.     if e != nil {  
52.         color.Red("发送HEAD请求出错！")  
53.         return e  
54.     }  
55.     // 读取并设定长度  
56.     task.TotalSize = response.ContentLength  
57.     return nil  
58. }  
59.   
60. // 根据待下载文件的大小和设定的并发数，创建每个分片任务对象  
61. func (task *ParallelGetTask) allocateTask() {  
62.     // 如果并发数大于总大小，则进行调整  
63.     if int64(task.Concurrent) > task.TotalSize {  
64.         task.Concurrent = int(task.TotalSize)  
65.     }  
66.     // 开始计算每个分片的下载范围  
67.     eachSize := task.TotalSize / int64(task.Concurrent)  
68.     // 创建任务对象  
69.     for i := 0; i < task.Concurrent; i++ {  
70.         task.ShardTaskList = append(task.ShardTaskList, NewShardTask(task.Url, i+1, filepath.Join(task.TempFolder, strconv.Itoa(i+1)), int64(i)*eachSize, int64(i+1)*eachSize-1))  
71.     }  
72.     // 处理末尾部分  
73.     if task.TotalSize%int64(task.Concurrent) != 0 {  
74.         task.ShardTaskList[task.Concurrent-1].RangeEnd = task.TotalSize - 1  
75.     }  
76. }  
77.   
78. // 根据任务列表进行多线程分片下载操作  
79. func (task *ParallelGetTask) downloadShard() {  
80.     // 创建线程组  
81.     waitGroup := &sync.WaitGroup{}  
82.     // 开始执行全部分片下载线程  
83.     for _, task := range task.ShardTaskList {  
84.         go task.DoShardGet(waitGroup)  
85.         waitGroup.Add(1)  
86.     }  
87.     // 等待全部下载完成  
88.     waitGroup.Wait()  
89. }  
90.   
91. // 下载完成后，合并分片文件  
92. func (task *ParallelGetTask) mergeFile() error {  
93.     // 创建目的文件  
94.     targetFile, e := os.OpenFile(task.FilePath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0755)  
95.     if e != nil {  
96.         color.Red("创建目标文件出错！")  
97.         return e  
98.     }  
99.     // 创建写入器  
100.     writer := bufio.NewWriter(targetFile)  
101.     // 准备读取每个分片文件  
102.     for _, shard := range task.ShardTaskList {  
103.         shardFile, e := os.OpenFile(shard.ShardFilePath, os.O_RDONLY, 0755)  
104.         if e != nil {  
105.             color.Red("读取分片文件出错！")  
106.             return e  
107.         }  
108.         reader := bufio.NewReader(shardFile)  
109.         readBuffer := make([]byte, 1024*1024)  
110.         for {  
111.             // 读取每个分片文件，一次读取1KB  
112.             readSize, readError := reader.Read(readBuffer)  
113.             // 处理结束或错误  
114.             if readError != nil {  
115.                 if readError == io.EOF {  
116.                     break  
117.                 } else {  
118.                     color.Red("读取分片文件出错！")  
119.                     return readError  
120.                 }  
121.             }  
122.             // 写入到最终合并的文件  
123.             _, writeError := writer.Write(readBuffer[0:readSize])  
124.             if writeError != nil {  
125.                 color.Red("写入合并文件出错！")  
126.                 return writeError  
127.             }  
128.             _ = writer.Flush()  
129.         }  
130.         // 关闭分片文件资源  
131.         _ = shardFile.Close()  
132.     }  
133.     // 关闭目的文件资源  
134.     _ = targetFile.Close()  
135.     return nil  
136. }  
137.   
138. // 删除分片临时文件  
139. func (task *ParallelGetTask) cleanShard() error {  
140.     for _, shard := range task.ShardTaskList {  
141.         e := os.Remove(shard.ShardFilePath)  
142.         if e != nil {  
143.             color.Red("删除分片临时文件%s出错！", shard.ShardFilePath)  
144.             return e  
145.         }  
146.     }  
147.     return nil  
148. }  
149.   
150. // 在一个新线程中，实时输出每个分片的下载进度和总进度  
151. func (task *ParallelGetTask) printTotalProcess() {  
152.     go func() {  
153.         // 上一次统计时的已下载大小，用于计算速度  
154.         var lastDownloadSize int64 = 0  
155.         for {  
156.             // 如果全部任务完成则结束输出，并统计并发数  
157.             allDone := true  
158.             // 当前并发数  
159.             currentTaskCount := 0  
160.             for _, shardTask := range task.ShardTaskList {  
161.                 if !shardTask.TaskDone {  
162.                     allDone = false  
163.                     currentTaskCount += 1  
164.                 }  
165.             }  
166.             if allDone {  
167.                 break  
168.             }  
169.             // 统计所有分片已下载大小之和  
170.             var totalDownloadSize int64 = 0  
171.             for _, shardTask := range task.ShardTaskList {  
172.                 totalDownloadSize += shardTask.DownloadSize  
173.             }  
174.             // 计算速度  
175.             currentDownload := totalDownloadSize - lastDownloadSize  
176.             lastDownloadSize = totalDownloadSize  
177.             speedString := util.ComputeSpeed(currentDownload, 300)  
178.             // 输出到控制台  
179.             fmt.Printf("\r当前并发数：%3d 速度：%s 总进度：%3.2f%%", currentTaskCount, speedString, float32(totalDownloadSize)/float32(task.TotalSize)*100)  
180.             // 等待300ms  
181.             time.Sleep(300 * time.Millisecond)  
182.         }  
183.     }()  
184. }  
185.   
186. // Run 开始执行整个分片多线程下载任务  
187. func (task *ParallelGetTask) Run() error {  
188.     // 获取文件大小  
189.     e := task.getLength()  
190.     if e != nil {  
191.         color.Red("%s", e)  
192.         return e  
193.     }  
194.     color.HiYellow("已获取到下载文件大小：%d字节", task.TotalSize)  
195.     // 分配任务  
196.     task.allocateTask()  
197.     color.HiYellow("已完成分片任务分配，共计%d个任务", len(task.ShardTaskList))  
198.     // 开启进度输出  
199.     task.printTotalProcess()  
200.     // 开始下载分片  
201.     task.downloadShard()  
202.     color.HiYellow("\n所有分片已下载完成！")  
203.     // 开始合并文件  
204.     e = task.mergeFile()  
205.     if e != nil {  
206.         color.Red("%s", e)  
207.         return e  
208.     }  
209.     color.HiYellow("合并分片完成！")  
210.     // 清理临时分片文件  
211.     e = task.cleanShard()  
212.     if e != nil {  
213.         color.Red("%s", e)  
214.         return e  
215.     }  
216.     color.HiYellow("清理分片临时文件完成！")  
217.     color.Green("分片下载任务完成！")  
218.     return nil  
219. }  

上述printTotalProcess函数中，util.ComputeSpeed函数用于计算下载速度并自动转换为可读单位，代码如下：

C#代码

1. package util  
2.   
3. import (  
4.     "fmt"  
5.     "math"  
6. )  
7.   
8. // 关于单位的实用工具函数  
9.   
10. // ComputeSpeed 计算网络速度  
11. // size 一段时间内下载的数据大小，单位字节  
12. // timeElapsed 经过的时间长度，单位毫秒  
13. // 返回计算得到的网速，会自动换算单位  
14. func ComputeSpeed(size int64, timeElapsed int) string {  
15.     bytePerSecond := size / int64(timeElapsed) * 1000  
16.     if 0 <= bytePerSecond && bytePerSecond <= 1024 {  
17.         return fmt.Sprintf("%4d Byte/s", bytePerSecond)  
18.     }  
19.     if bytePerSecond > 1024 && bytePerSecond <= int64(math.Pow(1024, 2)) {  
20.         return fmt.Sprintf("%6.2f KB/s", float64(bytePerSecond)/1024)  
21.     }  
22.     if bytePerSecond > 1024*1024 && bytePerSecond <= int64(math.Pow(1024, 3)) {  
23.         return fmt.Sprintf("%6.2f MB/s", float64(bytePerSecond)/math.Pow(1024, 2))  
24.     }  
25.     return fmt.Sprintf("%6.2f GB/s", float64(bytePerSecond)/math.Pow(1024, 3))  
26. }  

 

可见通过构造函数NewParallelGetTask完成参数传递和状态量设定后，其它每个私有函数都对应我们多线程下载中的一个步骤，最后由公开函数Run统筹组织起所有的步骤，完成整个多线程下载任务。

3，实现效果

现在我们在main函数中创建一个ParallelGetTask对象，设定好参数后调用其Run方法即可开始多线程下载文件的任务：

C#代码

1. package main  
2.   
3. import (  
4.     "gitee.com/swsk33/shard-download-demo/model"  
5. )  
6.   
7. func main() {  
8.     // 创建任务  
9.     task := model.NewParallelGetTask(  
10.         "https://github.com/jgraph/drawio-desktop/releases/download/v24.7.17/draw.io-24.7.17-windows-installer.exe",  
11.         "C:\\Users\\swsk33\\Downloads\\draw.io.exe",  
12.         64,  
13.         "C:\\Users\\swsk33\\Downloads\\temp",  
14.     )  
15.     // 执行任务  
16.     _ = task.Run()  
17. }  

 

使用SHELL脚本，删除指定文件或目录，

使用方法：bash /sh/delfiles.sh 11.txt 22.txt