Bei Verwendung von Goroutine zum Erstellen von Zip liegt der Slice außerhalb des zulässigen Bereichs und die Kapazität beträgt 4096

PHP-Redakteur Xiaoxin hat einen Artikel über die Verwendung von Goroutine zum Erstellen von Zip mitgebracht. In diesem Artikel erfahren Sie, wie Sie mit Goroutine gleichzeitig Zip-Vorgänge ausführen und so die Effizienz des Programms verbessern. Darüber hinaus werden wir das Problem des Slicings außerhalb des Bereichs diskutieren und zeigen, wie man dieses Problem durch Slicing mit einer Kapazität von 4096 lösen kann. Egal, ob Sie Anfänger oder erfahrener Entwickler sind, dieser Artikel hilft Ihnen, das Wissen rund um Goroutinen und Slicing besser zu verstehen und anzuwenden. Lasst uns gemeinsam erkunden!

Frageninhalt

Ich versuche, die Funktion zum Erstellen der ZIP-Datei zu verbessern, indem ich eine Goroutine hinzufüge, die jede Datei verarbeitet, die archiviert werden muss. Aber es endete in Panik panic：运行时错误：切片超出范围[4126：4096]

Das Zielverzeichnis enthält 190 Dateien (500 Monate). Ich verstehe wirklich nicht, was los ist Vielen Dank im Voraus für Ihre Hilfe

Eigenschaften:

func buildarchive() error {                                                        
                                                                                   
    var files []string                                                             
    err := filepath.walk("/tmp/dir-to-zip", func(filepath string, info os.fileinfo, err error) error {
        if info.isdir() {                                                          
            return nil                                                             
        }                                                                          
        if err != nil {                                                            
            fmt.println(err)                                                       
            return err                                                             
        }                                                                          
        files = append(files, filepath)                                            
                                                                                   
        return nil                                                                 
    })                                                                             
    if err != nil {                                                                
        return err                                                                 
    }                                                                              
                                                                                   
    bundle, err := os.create("/tmp/archive.zip")                                   
    if err != nil {                                                                
        return err                                                                 
    }                                                                              
    bundlewriter := zip.newwriter(bundle)                                          
                                                                                   
    var wg sync.waitgroup                                                          
    wg.add(len(files))                                                             
                                                                                   
    for _, filepath := range files {                                               
        go func(filepath string) {                                                 
            defer wg.done()                                                        
            relpath := strings.trimprefix(filepath, fmt.sprintf("%v/", filepath.dir("/tmp/dir-to-zip")))
                                                                                   
            bundlefile, err := bundlewriter.create(relpath)                        
            if err != nil {                                                        
                fmt.println(err)                                                   
            }                                                                      
            fsfile, err := os.open(filepath)                                       
            if err != nil {                                                        
                fmt.println(err)                                                   
            }                                                                      
            _, err = io.copy(bundlefile, fsfile)                                   
            if err != nil {                                                        
                fmt.println(err)                                                   
            }                                                                      
                                                                                   
        }(filepath)                                                                
    }                                                                              
    wg.wait()                                                                      
                                                                                   
    err = bundlewriter.close()                                                     
    if err != nil {                                                                
        return err                                                                 
    }                                                                              
    return nil                                                                     
}

Der Fehler ist hier aufgetreten:

_, err = io.copy(bundlefile, fsfile)                                   
        if err != nil {                                                        
            fmt.println(err)                                                   
        }

Stack-Trace:

goroutine 48 [running]:                                                            
bufio.(*Writer).Write(0xc00002a100, {0xc00041a400?, 0x3d?, 0xc00041a400?})         
    /usr/local/go/src/bufio/bufio.go:670 +0x1c8                                    
archive/zip.(*countWriter).Write(0xc00000c138, {0xc00041a400?, 0x3d?, 0x4afa20?})
    /usr/local/go/src/archive/zip/writer.go:601 +0x2e                              
io.WriteString({0x4e7538, 0xc00000c138}, {0xc0000212c9, 0x3d})                     
    /usr/local/go/src/io/io.go:314 +0x91                                           
archive/zip.writeHeader({0x4e7538, 0xc00000c138}, 0xc000220090)                    
    /usr/local/go/src/archive/zip/writer.go:422 +0x5ec                             
archive/zip.(*Writer).CreateHeader(0xc0000760a0, 0xc00021e1b0)                     
    /usr/local/go/src/archive/zip/writer.go:378 +0x797                             
archive/zip.(*Writer).Create(0x4e7698?, {0xc0000212c9, 0x3d})                      
    /usr/local/go/src/archive/zip/writer.go:223 +0x6c                              
main.BuildArchive.func2({0xc0000212c0, 0x46})                                      
    /home/simba/go/src/foobar/main.go:79 +0x1c5                                    
created by main.BuildArchive                                                       
    /home/simba/go/src/foobar/main.go:73 +0x5aa                                    
panic: runtime error: slice bounds out of range [:4126] with capacity 4096         
                                                                                   
goroutine 6 [running]:                                                             
bufio.(*Writer).Flush(0xc00002a100)                                                
    /usr/local/go/src/bufio/bufio.go:634 +0x171                                    
bufio.(*Writer).Write(0xc00002a100, {0xc0001b4200?, 0xc000199b20?, 0xc000199b20?})
    /usr/local/go/src/bufio/bufio.go:672 +0xd8                                     
archive/zip.(*countWriter).Write(0xc00000c138, {0xc0001b4200?, 0x0?, 0xc000199b40?})
    /usr/local/go/src/archive/zip/writer.go:601 +0x2e                              
archive/zip.(*countWriter).Write(0xc000220018, {0xc0001b4200?, 0xc0001b02c0?, 0xc0001b02f0?})
    /usr/local/go/src/archive/zip/writer.go:601 +0x2e                              
compress/flate.(*huffmanBitWriter).write(...)                                      
    /usr/local/go/src/compress/flate/huffman_bit_writer.go:136                     
compress/flate.(*huffmanBitWriter).writeCode(0xc0001b41e0?, {0x6000?, 0x22?})   
    /usr/local/go/src/compress/flate/huffman_bit_writer.go:347 +0xe5               
compress/flate.(*huffmanBitWriter).writeTokens(0xc0001b41e0, {0xc002558000, 0x4001, 0x403f800000403f?}, {0xc0001aa900, 0x11e, 0x108129000000000f?}, {0xc0001ac100, 0x1e, 0x1e})
    /usr/local/go/src/compress/flate/huffman_bit_writer.go:583 +0xb9               
compress/flate.(*huffmanBitWriter).writeBlock(0xc0001b41e0, {0xc002558000?, 0x20?, 0xd79?}, 0x0, {0x0, 0x0, 0x0})
    /usr/local/go/src/compress/flate/huffman_bit_writer.go:495 +0x490              
compress/flate.(*compressor).writeBlock(0xc0005a2000, {0xc002558000?, 0xc000032f00?, 0xc000199d28?}, 0x47739b?)
    /usr/local/go/src/compress/flate/deflate.go:170 +0x9c                          
compress/flate.(*compressor).deflate(0xc0005a2000)                                 
    /usr/local/go/src/compress/flate/deflate.go:509 +0x59b                         
compress/flate.(*compressor).write(0xc0005a2000, {0xc00256a000?, 0x8000, 0xf311b6fd?})
    /usr/local/go/src/compress/flate/deflate.go:554 +0x82                          
compress/flate.(*Writer).Write(...)                                                
    /usr/local/go/src/compress/flate/deflate.go:712                                
archive/zip.(*pooledFlateWriter).Write(0xc00020c040?, {0xc00256a000?, 0x8000?, 0x4af140?})
    /usr/local/go/src/archive/zip/register.go:51 +0xc5                             
archive/zip.(*countWriter).Write(...)                                              
    /usr/local/go/src/archive/zip/writer.go:601                                    
archive/zip.(*fileWriter).Write(0xc000222000, {0xc00256a000, 0x8000, 0x8000})   
    /usr/local/go/src/archive/zip/writer.go:533 +0x97                              
io.copyBuffer({0x4e7558, 0xc000222000}, {0x4e7678, 0xc0001f8008}, {0x0, 0x0, 0x0})
    /usr/local/go/src/io/io.go:428 +0x204                                          
io.Copy(...)                                                                       
    /usr/local/go/src/io/io.go:385                                                 
main.BuildArchive.func2({0xc00001c0c0, 0x35})                                      
    /home/simba/go/src/foobar/main.go:89 +0x385                                    
created by main.BuildArchive                                                       
    /home/simba/go/src/foobar/main.go:73 +0x5aa                                    
exit status 2

Lösung

zip.Writer Nicht sicher für die gleichzeitige Verwendung. Sie starten mehrere Goroutinen, jede Goroutine erstellt und schreibt ZIP-Einträge (Dateien).

Writer.Create() Aufnahme:

Create fügt die Datei unter dem angegebenen Namen zur ZIP-Datei hinzu. Es gibt einen Writer zurück, in den der Dateiinhalt geschrieben werden soll.

[...] Der Dateiinhalt muss vor dem nächsten Aufruf von Create, CreateHeader oder Close in io.Writer geschrieben werden.

Sie können nicht gleichzeitig eine Zip-Datei erstellen. io.Writers 写入相同的底层文件（或一般情况下相同的 io.Writer) Für jeden Zip-Eintrag kann das resultierende Zip-Archiv ungültig sein, auch wenn Ihre Anwendung nicht in Panik gerät oder abstürzt.

Das obige ist der detaillierte Inhalt vonBei Verwendung von Goroutine zum Erstellen von Zip liegt der Slice außerhalb des zulässigen Bereichs und die Kapazität beträgt 4096. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!