Bagaimana golang mengendalikan fail besar

Dalam pembangunan, kami sering menghadapi situasi di mana kami perlu memproses fail besar Sebagai bahasa yang cekap dan sesuai untuk pemprosesan serentak, bahasa Go secara semula jadi akan melibatkan pemprosesan fail besar. Sama ada anda membaca, menulis atau mengubah suai fail besar, anda perlu mempertimbangkan beberapa isu, seperti: Bagaimana untuk mengelakkan kebocoran memori? Bagaimana untuk menanganinya dengan cekap? Dalam artikel ini, kami akan memperkenalkan beberapa kaedah untuk memproses fail besar dan memberi tumpuan kepada cara menangani fail yang terlalu besar untuk mengelakkan ranap program.

1. Gunakan pemprosesan berpecah

Secara amnya, sama ada anda membaca, menulis atau mengubah suai fail besar, anda perlu mempertimbangkan cara untuk mengelakkan kebocoran memori dan ranap program. Untuk memproses fail besar dengan berkesan, pemprosesan split sering digunakan untuk membahagikan fail besar kepada berbilang fail kecil, dan kemudian membaca dan menulis fail kecil.

Dalam bahasa Go, kami boleh membahagikan fail melalui kaedah io.LimitReader() dan io.MultiReader(), membahagikan fail besar kepada berbilang fail kecil dan menggunakan pemprosesan berbilang benang.

Baca fail besar melebihi 500MB melalui kod berikut:

var (
    maxSize int64 = 100 * 1024 * 1024 //100MB
)
func readBigFile(filename string) (err error) {
    file, err := os.Open(filename)
    if err != nil {
        return err
    }
    defer file.Close()

    fileInfo, err := file.Stat()
    if err != nil {
        return err
    }

    if fileInfo.Size() <= maxSize {
        _, err = io.Copy(os.Stdout, file)
    } else {
        n := (fileInfo.Size() + (maxSize - 1)) / maxSize
        var err error
        for i := int64(0); i < n; i++ {
            eachSize := maxSize
            if i == n-1 {
                eachSize = fileInfo.Size() - (n-1)*maxSize
            }
            sectionReader := io.NewSectionReader(file, i*maxSize, eachSize)
            _, err = io.Copy(os.Stdout, sectionReader)
            if err != nil {
                return err
            }
        }
    }
    return nil
}

Dalam kod di atas, apabila saiz fail dibaca melebihi nilai maksimum yang dibenarkan, kaedah bacaan kompaun akan digunakan , bahagikan besar fail ke dalam berbilang blok dengan saiz yang sama untuk membaca, dan akhirnya menggabungkannya ke dalam hasil akhir.

Kaedah di atas sudah tentu dioptimumkan untuk proses membaca fail yang besar Kadang-kadang kita juga mempunyai keperluan menulis fail.

2. Tulis fail besar

Cara paling mudah untuk menulis fail besar dalam Go ialah menggunakan fungsi bufio.NewWriterSize() yang dibalut dengan os.File() dan gunakan Tulis Tentukan sama ada penimbal semasa penuh sebelum memanggil kaedah Flush() untuk menulis data dalam penimbal ke cakera keras. Kaedah menulis fail besar ini mudah dan mudah dilaksanakan serta sesuai untuk menulis fail besar.

    writer := bufio.NewWriterSize(file, size)
    defer writer.Flush()
    _, err = writer.Write(data)

3. Mengendalikan Fail CSV Besar

Selain membaca dan menulis fail besar, kami juga mungkin memproses fail CSV yang besar. Apabila memproses fail CSV, jika fail itu terlalu besar, ia akan menyebabkan beberapa ranap program, jadi kami perlu menggunakan beberapa alatan untuk memproses fail CSV yang besar ini. Bahasa Go menyediakan mekanisme yang dipanggil goroutine dan saluran, yang boleh memproses berbilang fail pada masa yang sama untuk mencapai tujuan memproses fail CSV besar dengan cepat.

Dalam bahasa Go, kita boleh menggunakan kaedah csv.NewReader() dan csv.NewWriter() untuk membina pemproses untuk membaca dan menulis fail CSV masing-masing, kemudian mengimbas fail baris demi baris untuk membaca data. Gunakan saluran paip dalam fail CSV untuk memproses cara data disimpan baris demi baris.

func readCSVFile(path string, ch chan []string) {
    file, err := os.Open(path)
    if err != nil {
        log.Fatal("读取文件失败:", err)
    }
    defer file.Close()
    reader := csv.NewReader(file)
    for {
        record, err := reader.Read()
        if err == io.EOF {
            break
        } else if err != nil {
            log.Fatal("csv文件读取失败:", err)
        }
        ch <- record
    }
    close(ch)
}

func writeCSVFile(path string, ch chan []string) {
    file, err := os.Create(path)
    if err != nil {
        log.Fatal("创建csv文件失败:", err)
    }
    defer file.Close()
    writer := csv.NewWriter(file)
    for record := range ch {
        if err := writer.Write(record); err != nil {
            log.Fatal("csv文件写入失败: ", err)
        }
        writer.Flush()
    }
}

Dalam kod di atas, gunakan kaedah csv.NewReader() untuk lelaran melalui fail, simpan setiap baris data dalam tatasusunan, dan kemudian hantar tatasusunan ke saluran. Semasa membaca fail CSV, kami menggunakan goroutine dan saluran untuk mengimbas keseluruhan fail secara serentak. Selepas membaca, kami menutup saluran untuk menunjukkan bahawa kami telah selesai membaca fail.

Melalui kaedah di atas, anda tidak perlu lagi membaca keseluruhan data ke dalam memori semasa memproses fail besar, mengelakkan kebocoran memori dan ranap program, dan juga meningkatkan kecekapan operasi program.

Ringkasan:

Dalam pengenalan di atas, kami meneroka beberapa kaedah memproses fail besar, termasuk menggunakan pemprosesan pisah, menulis fail besar dan memproses fail CSV besar. Dalam pembangunan sebenar, kita boleh memilih cara yang sesuai untuk memproses fail besar berdasarkan keperluan perniagaan untuk meningkatkan prestasi dan kecekapan program. Pada masa yang sama, apabila memproses fail besar, kita perlu menumpukan pada isu ingatan, merancang penggunaan memori secara munasabah dan mengelakkan kebocoran memori.

Apabila menggunakan bahasa Go untuk memproses fail besar, kami boleh menggunakan sepenuhnya ciri bahasa Go, seperti goroutine dan saluran, supaya atur cara boleh memproses fail besar dengan cekap dan mengelakkan kebocoran memori dan ranap program. Walaupun artikel ini memperkenalkan kandungan yang agak asas, kaedah ini boleh digunakan untuk pemprosesan fail besar semasa pembangunan, dengan itu meningkatkan prestasi dan kecekapan program.

Atas ialah kandungan terperinci Bagaimana golang mengendalikan fail besar. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!