在 Golang 中以最快的方式解压 tar 文件

今日不肯埋头，明日何以抬头！每日一句努力自己的话哈哈~哈喽，今天我将给大家带来一篇《在 Golang 中以最快的方式解压 tar 文件》，主要内容是讲解等等，感兴趣的朋友可以收藏或者有更好的建议在评论提出，我都会认真看的！大家一起进步，一起学习！

我有一个 tar 文件，其中包含多个 tar 文件。我目前正在使用 tar reader 通过手动移动文件来递归地提取这些 tars。这个过程非常繁重且缓慢，尤其是在处理包含数千个文件和目录的大型 tar 文件时。

我没有找到任何能够快速执行递归提取的好包。另外，我尝试使用命令 tar -xf file.tar --same-owner" 作为内部 tar，但遇到了权限问题（仅发生在 mac 上）。

我的问题是： 有没有办法并行化手动提取过程，以便并行提取内部焦油？

我有一个提取任务的方法，我正在尝试并行化：

var wg sync.waitgroup
    wg.add(len(tarfiles))

    for {
        header, err := tarballreader.next()
        if err != nil {
            break
        }
        go extractfileasync(parentfolder, header, tarballreader, depth, &wg)
    }
    wg.wait()

添加 go 例程后，文件被损坏，并且进程陷入无限循环。

主要 tar 内容示例：

1d2755f3375860aaaf2b5f0474692df2e0d4329569c1e8187595bf4b3bf3f3b9/
1d2755f3375860aaaf2b5f0474692df2e0d4329569c1e8187595bf4b3bf3f3b9/VERSION
1d2755f3375860aaaf2b5f0474692df2e0d4329569c1e8187595bf4b3bf3f3b9/json
1d2755f3375860aaaf2b5f0474692df2e0d4329569c1e8187595bf4b3bf3f3b9/layer.tar
348188998f2a69b4ac0ca96b42990292eef67c0abfa05412e2fb7857645f4280/
348188998f2a69b4ac0ca96b42990292eef67c0abfa05412e2fb7857645f4280/VERSION
348188998f2a69b4ac0ca96b42990292eef67c0abfa05412e2fb7857645f4280/json
348188998f2a69b4ac0ca96b42990292eef67c0abfa05412e2fb7857645f4280/layer.tar
54c027bf04447fdb035ddc13a6ae5493a3f997bdd3577607b0980954522efb9e.json
9dd3c29af50daaf86744a8ade86ecf12f6a5a6ffc27a5a7398628e4a21770ee3/
9dd3c29af50daaf86744a8ade86ecf12f6a5a6ffc27a5a7398628e4a21770ee3/VERSION
9dd3c29af50daaf86744a8ade86ecf12f6a5a6ffc27a5a7398628e4a21770ee3/json
9dd3c29af50daaf86744a8ade86ecf12f6a5a6ffc27a5a7398628e4a21770ee3/layer.tar
b6c49400b643245cdbe17b7a7eb14f0f7def5a93326b99560241715c1e95502e/
b6c49400b643245cdbe17b7a7eb14f0f7def5a93326b99560241715c1e95502e/VERSION
b6c49400b643245cdbe17b7a7eb14f0f7def5a93326b99560241715c1e95502e/json
b6c49400b643245cdbe17b7a7eb14f0f7def5a93326b99560241715c1e95502e/layer.tar
c662ec0dc487910e7b76b2a4d67ab1a9ca63ce1784f636c2637b41d6c7ac5a1e/
c662ec0dc487910e7b76b2a4d67ab1a9ca63ce1784f636c2637b41d6c7ac5a1e/VERSION
c662ec0dc487910e7b76b2a4d67ab1a9ca63ce1784f636c2637b41d6c7ac5a1e/json
c662ec0dc487910e7b76b2a4d67ab1a9ca63ce1784f636c2637b41d6c7ac5a1e/layer.tar
da87454b77f6ac7fab1f465c10a07a1eb4b46df8058d98892794618cac8eacdc/
da87454b77f6ac7fab1f465c10a07a1eb4b46df8058d98892794618cac8eacdc/VERSION
da87454b77f6ac7fab1f465c10a07a1eb4b46df8058d98892794618cac8eacdc/json
da87454b77f6ac7fab1f465c10a07a1eb4b46df8058d98892794618cac8eacdc/layer.tar
ea1c2adfdc777d8746e50ad3e679789893a991606739c9bc7e01f273fa0b6e12/
ea1c2adfdc777d8746e50ad3e679789893a991606739c9bc7e01f273fa0b6e12/VERSION
ea1c2adfdc777d8746e50ad3e679789893a991606739c9bc7e01f273fa0b6e12/json
ea1c2adfdc777d8746e50ad3e679789893a991606739c9bc7e01f273fa0b6e12/layer.tar
f3b6608e814053048d79e519be79f654a2e9364dfdc8fb87b71e2fc57bbff115/
f3b6608e814053048d79e519be79f654a2e9364dfdc8fb87b71e2fc57bbff115/VERSION
f3b6608e814053048d79e519be79f654a2e9364dfdc8fb87b71e2fc57bbff115/json
f3b6608e814053048d79e519be79f654a2e9364dfdc8fb87b71e2fc57bbff115/layer.tar
manifest.json
repositories

或者只需运行 docker save : -o image.tar 并检查 tar 的内容。

正确答案

您的代码可能挂在 wg.wait() 上，因为执行期间对 wg.done() 的调用次数不等于 len(tarfiles)。

这应该有效：

    var wg sync.waitgroup
    // wg.add(len(tarfiles))

    for {
        header, err := tarballreader.next()
        if err != nil {
            break
        }
        wg.add(1)
        go extractfileasync(parentfolder, header, tarballreader, depth, &wg)
    }
    wg.wait()

func extractfileasync(...) {
    defer wg.done()

    // some code

}

upd：修正可能的竞争条件。谢谢@craigb

这是我对类似问题的解决方案（简化）：

package main

import (
    "archive/tar"
    "fmt"
    "io"
    "os"
    "path/filepath"
    "strings"
    "sync"
)

type Semaphore struct {
    Wg sync.WaitGroup
    Ch chan int
}

// Limit on the number of simultaneously running goroutines.
// Depends on the number of processor cores, storage performance, amount of RAM, etc.
const grMax = 10

const tarFileName = "docker_image.tar"
const dstDir = "output/docker"

func extractTar(tarFileName string, dstDir string) error {
    f, err := os.Open(tarFileName)
    if err != nil {
        return err
    }

    sem := Semaphore{}
    sem.Ch = make(chan int, grMax)

    if err := Untar(dstDir, f, &sem, true); err != nil {
        return err
    }

    fmt.Println("extractTar: wait for complete")
    sem.Wg.Wait()
    return nil
}


func Untar(dst string, r io.Reader, sem *Semaphore, godeep bool) error {

    tr := tar.NewReader(r)

    for {
        header, err := tr.Next()

        switch {
        case err == io.EOF:
            return nil
        case err != nil:
            return err
        }

        // the target location where the dir/file should be created
        target := filepath.Join(dst, header.Name)

        switch header.Typeflag {

        // if its a dir and it doesn't exist create it
        case tar.TypeDir:
            if _, err := os.Stat(target); err != nil {
                if err := os.MkdirAll(target, 0755); err != nil {
                    return err
                }
            }

        // if it's a file create it
        case tar.TypeReg:
            if err := saveFile(tr, target, os.FileMode(header.Mode)); err != nil {
                return err
            }
            ext := filepath.Ext(target)

            // if it's tar file and we are on top level, extract it
            if ext == ".tar" && godeep {
                sem.Wg.Add(1)
                // A buffered channel is used to limit the number of simultaneously running goroutines
                sem.Ch <- 1
                // the file is unpacked to a directory with the file name (without extension)
                newDir := filepath.Join(dst, strings.TrimSuffix(header.Name, ".tar"))
                if err := os.Mkdir(newDir, 0755); err != nil {
                    return err
                }
                go func(target string, newDir string, sem *Semaphore) {
                    fmt.Println("start goroutine, chan length:", len(sem.Ch))
                    fmt.Println("START:", target)
                    defer sem.Wg.Done()
                    defer func() {<-sem.Ch}()
                    // the internal tar file opens
                    ft, err := os.Open(target)
                    if err != nil {
                        fmt.Println(err)
                        return
                    }
                    defer ft.Close()
                    // the godeep parameter is false here to avoid unpacking archives inside the current archive.
                    if err := Untar(newDir, ft, sem, false); err != nil {
                        fmt.Println(err)
                        return
                    }
                    fmt.Println("DONE:", target)
                }(target, newDir, sem)
            }
        }
    }
    return nil
}

func saveFile(r io.Reader, target string, mode os.FileMode) error {
    f, err := os.OpenFile(target, os.O_CREATE|os.O_RDWR, mode)
    if err != nil {
        return err
    }
    defer f.Close()

    if _, err := io.Copy(f, r); err != nil {
        return err
    }
    
    return nil
}

func main() {
    err := extractTar(tarFileName, dstDir)
    if err != nil {
        fmt.Println(err)
    }
}

好了，本文到此结束，带大家了解了《在 Golang 中以最快的方式解压 tar 文件》，希望本文对你有所帮助！关注golang学习网公众号，给大家分享更多Golang知识！