Editor PHP Youzi memperkenalkan anda kepada teknik untuk mengoptimumkan penggunaan memori - membebaskan memori daripada objek besar. Semasa proses pembangunan, kami sering mencipta beberapa objek besar, seperti tatasusunan besar atau hasil pertanyaan pangkalan data yang besar, dan objek ini mengambil banyak sumber memori. Apabila kita selesai menggunakan objek ini, ia adalah tabiat pengaturcaraan yang baik untuk melepaskan memori dalam masa. Artikel ini akan menunjukkan kepada anda cara mengosongkan memori daripada objek besar untuk meningkatkan prestasi dan kecekapan aplikasi.
Saya terjumpa sesuatu yang saya tidak faham. Harap anda semua boleh membantu!
Sumber:
Saya membaca dalam beberapa artikel bahawa kami boleh memudahkan tugas gc dengan menetapkan kepingan besar dan peta (saya rasa ini terpakai kepada semua jenis rujukan) kepada nil selepas kami tidak memerlukannya lagi. Ini salah satu contoh yang pernah saya baca:
func ProcessResponse(resp *http.Response) error {
data, err := ioutil.ReadAll(resp.Body)
if err != nil {
return err
}
// Process data here
data = nil // Release memory
return nil
}Seperti yang saya faham, apabila fungsi processresponse 完成时，data 变量将超出范围，基本上将不再存在。然后，gc 将验证是否没有对 []byte 切片（data menunjuk kepada rujukan kepada kepingan), ingatan akan dikosongkan.
Tetapkan data 设置为 nil Bagaimana untuk menambah baik kutipan sampah?
Terima kasih!
data = nil 不会改变 gc 方面的任何内容。 go 编译器将应用优化，并且 golang 的垃圾收集器在不同的阶段工作。用最简单的术语（有许多遗漏和过度简化）：设置 data = nil sebelum kembali, dan mengalih keluar semua rujukan kepada kepingan asas tidak mencetuskan pelepasan memori gaya atom yang tidak lagi dirujuk. Sebaik sahaja hirisan tidak lagi dirujuk, ia ditandakan sedemikian dan memori yang berkaitan tidak dikeluarkan sehingga imbasan seterusnya.
Pengumpulan sampah adalah masalah yang sukar, terutamanya kerana ia bukan jenis masalah yang mempunyai penyelesaian optimum yang menghasilkan hasil terbaik untuk semua kes penggunaan. Masa jalan pergi telah banyak berkembang selama bertahun-tahun, dan kerja penting dilakukan pada pengumpul sampah masa jalan. Hasilnya ialah, dalam kes yang jarang berlaku, somevar = nil yang mudah akan membuat walaupun kecil, apatah lagi perbezaan yang ketara.
Jika anda sedang mencari beberapa petua jenis peraturan mudah yang mungkin memberi kesan kepada overhed masa jalan yang dikaitkan dengan kutipan sampah (atau pengurusan memori masa jalan secara amnya), saya tahu bahawa ayat ini nampaknya merangkumi samar-samar dalam ayat anda. soalan:
Adalah dicadangkan agar kita dapat memudahkan kerja gc dengan menyediakan kepingan besar dan pemetaan
Ini boleh menghasilkan hasil yang ketara apabila menganalisis kod. Dengan mengandaikan anda sedang membaca sejumlah besar data yang perlu diproses, atau anda perlu melakukan beberapa jenis operasi kelompok lain dan memulangkan hirisan, bukan perkara biasa bagi orang untuk menulis sesuatu seperti ini:
func processstuff(input []sometypes) []resulttypes {
data := []resulttypes{}
for _, in := range input {
data = append(data, processt(in))
}
return data
}Mudah untuk dioptimumkan dengan menukar kod kepada:
func processstuff(input []sometypes) []resulttypes {
data := make([]resulttypes, 0, len(input)) // set cap
for _, in := range input {
data = append(data, processt(in))
}
return data
}Apa yang berlaku dalam pelaksanaan pertama ialah apabila anda menggunakan len 和 cap 为 0 创建一个切片。第一次调用 append anda melebihi kapasiti semasa hirisan, yang menyebabkan masa jalan memperuntukkan memori. Seperti yang dijelaskan di sini, pengiraan kapasiti baharu adalah agak mudah, memori diperuntukkan dan data disalin ke atas:
t := make([]byte, len(s), (cap(s)+1)*2) copy(t, s)
Pada asasnya, setiap kali hirisan yang hendak dilampirkan penuh (iaitu len == cap）调用 append 时，您将分配一个可容纳： (len + 1) * 2 元素的新切片。知道在第一个示例中 data 以 len 和 cap == 0 sebagai permulaan, mari lihat maksudnya:
1st iteration: append creates slice with cap (0+1) *2, data is now len 1, cap 2 2nd iteration: append adds to data, now has len 2, cap 2 3rd iteration: append allocates a new slice with cap (2 + 1) *2, copies the 2 elements from data to this slice and adds the third, data is now reassigned to a slice with len 3, cap 6 4th-6th iterations: data grows to len 6, cap 6 7th iteration: same as 3rd iteration, although cap is (6 + 1) * 2, everything is copied over, data is reassigned a slice with len 7, cap 14
Jika struktur data dalam hirisan adalah besar (iaitu banyak struktur bersarang, banyak arahan, dll.), maka pengagihan semula dan penyalinan yang kerap ini boleh menjadi agak mahal. Jika kod anda mengandungi banyak gelung ini, ia akan mula dipaparkan dalam pprof (anda akan mula melihat panggilan mengambil banyak masa gcmalloc). Selain itu, jika anda sedang memproses 15 nilai input, kepingan data anda akan kelihatan seperti ini:
dataslice {
len: 15
cap: 30
data underlying_array[30]
}Ini bermakna anda akan memperuntukkan memori untuk 30 nilai apabila anda hanya memerlukan 15, dan anda akan memperuntukkan memori tersebut kepada 4 bahagian yang lebih besar secara beransur-ansur, menyalin data pada setiap pengagihan semula.
Sebaliknya, pelaksanaan kedua akan memperuntukkan kepingan data seperti ini sebelum gelung:
data {
len: 0
cap: 15
data underlying_array[15]
}Ia diperuntukkan sekali, jadi tiada peruntukan semula dan penyalinan diperlukan, dan kepingan yang dikembalikan akan menduduki separuh ruang memori. Dalam pengertian ini, kami mula-mula memperuntukkan blok memori yang lebih besar pada permulaan untuk mengurangkan bilangan peruntukan tambahan dan menyalin panggilan yang diperlukan kemudian, yang secara keseluruhan mengurangkan kos masa jalan.
这是一个公平的问题。这个例子并不总是适用。在这种情况下，我们知道需要多少个元素，并且可以相应地分配内存。有时，世界并不是这样运作的。如果您不知道最终需要多少数据，那么您可以：
不，将一个简单的切片变量设置为 nil 在 99% 的情况下不会产生太大影响。创建和附加到地图/切片时，更可能产生影响的是通过使用 make() + 指定合理的 cap 值来减少无关分配。其他可以产生影响的事情是使用指针类型/接收器，尽管这是一个需要深入研究的更复杂的主题。现在，我只想说，我一直在开发一个代码库，该代码库必须对远远超出典型 uint64 范围的数字进行操作，不幸的是，我们必须能够以更精确的方式使用小数比 float64 将允许。我们通过使用像 holiman/uint256 这样的东西解决了 uint64 问题，它使用指针接收器，并解决shopspring/decimal 的十进制问题，它使用值接收器并复制所有内容。在花费大量时间优化代码之后，我们已经达到了使用小数时不断复制值的性能影响已成为问题的地步。看看这些包如何实现加法等简单操作，并尝试找出哪个操作成本更高：
// original a, b := 1, 2 a += b // uint256 version a, b := uint256.NewUint(1), uint256.NewUint(2) a.Add(a, b) // decimal version a, b := decimal.NewFromInt(1), decimal.NewFromInt(2) a = a.Add(b)
这些只是我在最近的工作中花时间优化的几件事，但从中得到的最重要的一点是：
当您处理更复杂的问题/代码时，您需要花费大量精力来研究切片或映射的分配周期，因为潜在的瓶颈和优化需要付出很大的努力。您可以而且可以说应该采取措施避免过于浪费（例如，如果您知道所述切片的最终长度是多少，则设置切片上限），但您不应该浪费太多时间手工制作每一行，直到该代码的内存占用尽可能小。成本将是：代码更脆弱/更难以维护和阅读，整体性能可能会恶化（说真的，你可以相信 go 运行时会做得很好），大量的血、汗和泪水，以及急剧下降在生产力方面。
Atas ialah kandungan terperinci Lepaskan ingatan daripada objek besar. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!
![[Web front-end] Permulaan pantas Node.js](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
