Блог

Существует несколько способов добавления к массиву. Интересно, известен ли наилучший способ добавления к огромному массиву (100 МБ) неизвестной длины? Я хочу избежать копирования, поскольку это увеличивает вероятность нехватки памяти и снижает производительность. Должен ли я рассмотреть возможность использования двумерных массивов?

В Golang у нас есть array и slice.

Массивы имеют фиксированный размер, когда вам нужно больше места, вам нужно создать массив большего размера, скопировать все значения из старого массива и заменить старую ссылку на новый массив.

Вы не должны хранить ссылку на старый массив, поэтому в этой памяти будет собран мусор.

В качестве альтернативы вы можете использовать slices (которые являются оболочкой поверх массива). Изменение размера и копирование будут выполнены за вас автоматически.

Вы также можете управлять изменением размера вручную, это может уменьшить GC. Но его следует профилировать и сравнивать с фрагментами.

Я добавил пример с хранением в многомерном массиве, я настоятельно рекомендую избегать этого подхода. Это усложнит и замедлит обход, повысит вероятность утечек памяти и многое другое. Сбор данных в Golang выполняется чрезвычайно быстро.

 BenchmarkStore/array-6            100000         20090 ns/op           0 B/op          0 allocs/op
BenchmarkStore/slice-6              5000        259940 ns/op     4654337 B/op         30 allocs/op
BenchmarkStore/Custom-6            10000        194152 ns/op     1747860 B/op          8 allocs/op
BenchmarkStore/Dimensions-6         3000        418654 ns/op     4458593 B/op         20 allocs/op
  

 package main

import (
    "testing"
)

const size = 100000

// Wrapper around slice
type MyStore struct {
    growthFactor int
    watermark    int
    Data         []int
}

func NewMyStore(growthFactor, initialSize int) *MyStore {
    return amp;MyStore{growthFactor: growthFactor, watermark: -1, Data: make([]int, initialSize)}
}

func (s *MyStore) Append(v int) {
    nextPosition := s.watermark   1
    currentSize := len(s.Data)
    full := currentSize == nextPosition
    if full {
        dataResize := make([]int, currentSize*s.growthFactor)
        copy(dataResize, s.Data)
        s.Data = dataResize
    }

    s.Data[nextPosition] = v
    s.watermark = nextPosition
}

// Dimensions
const chunkSize = 10
type MyStoreMultiDimensions struct {
    size      int
    watermark int
    data      [][chunkSize]int
}

func NewStoreMultiDimensions(chunks int) *MyStoreMultiDimensions {
    return amp;MyStoreMultiDimensions{watermark: -1, data: make([][chunkSize]int, chunks)}
}

func (s *MyStoreMultiDimensions) Append(v int) {
    nextPosition := s.watermark   1
    chunk := nextPosition / chunkSize
    if len(s.data) <= chunk {
        s.data = append(s.data, [chunkSize]int{})
    }

    s.data[chunk][nextPosition%chunkSize] = v
    s.watermark = nextPosition
}

func BenchmarkStore(b *testing.B) {
    b.Run("array", func(b2 *testing.B) {
        for i := 0; i < b2.N; i   {
            var store [size]int
            for item := 0; item < size; item   {
                store[item] = item
            }
        }
    })
    b.Run("slice", func(b2 *testing.B) {
        for i := 0; i < b2.N; i   {
            var store []int
            for item := 0; item < size; item   {
                store = append(store, item)
            }
        }
    })
    b.Run("Custom", func(b2 *testing.B) {
        for i := 0; i < b2.N; i   {
            var store = NewMyStore(4, 10)
            for item := 0; item < size; item   {
                store.Append(item)
            }
        }
    })
    b.Run("Dimensions", func(b2 *testing.B) {
        for i := 0; i < b2.N; i   {
            var store = NewStoreMultiDimensions(2)
            for item := 0; item < size; item   {
                store.Append(item)
            }
        }
    })
}
  

По моему мнению, вам следует рассмотреть возможность использования ArrayList вместо array. Затем вы можете использовать add() из ArrayList для добавления новых элементов.