So verlängern Sie die Obergrenze in Golang

Golang ist eine Programmiersprache für die Entwicklung hoher Parallelität und hervorragender Leistung. Sie bietet integrierte Unterstützung auf Sprachebene, wie z. B. Goroutine und Channel. Bei der Verarbeitung großer Datenmengen kann die Obergrenze (Kapazität) von Golang jedoch möglicherweise nicht den Bedarf decken, was zu Leistungsproblemen im Programm führt. In diesem Artikel erfahren Sie, wie Sie die Obergrenze von Golang erweitern, die Programmleistung optimieren und die Ausführung Ihres Programms beschleunigen können.

1. Was ist Cap?

Zunächst müssen wir wissen, was Cap ist. In Golang verfügen die beiden Datenstrukturen Slice und Map über ein Attribut namens cap, das die Kapazität des zugrunde liegenden Arrays des Slice oder der Map darstellt. Die Kapazität ist die Anzahl der Elemente, die dem Slice oder der Karte vorab zugewiesen sind. Wenn ein Programm Elemente zu einem Slice oder einer Map hinzufügt und die Kapazität des Slice oder der Map überschritten wird, wird das zugrunde liegende Array erweitert. Die Erweiterung führt zu einer Neuzuweisung des Speichers und zum Kopieren von Daten, wodurch die Programmleistung beeinträchtigt wird.

2. Erweitern Sie die Obergrenze des Slice

2.1. Obergrenze vorab zuweisen

Wir können beim Erstellen des Slice eine größere Obergrenze vorab zuweisen, anstatt die Kapazität dynamisch zu erweitern, während das Programm ausgeführt wird. Dadurch kann die Anzahl der Erweiterungen reduziert und die Programmleistung verbessert werden.

arr := make([]int, 0, 1000)
// 从空slice开始，容量为1000

2.2. Manuelle Erweiterung

Wir können die Kappe des Slice auch manuell erweitern. Wenn wir die Anzahl der Elemente kennen, die im Slice gespeichert werden müssen, können wir dem Slice zunächst eine kleinere Obergrenze zuweisen und diese nach Bedarf erweitern.

arr := make([]int, 0, 10)
// 先分配一个容量为10的底层数组
for i := 0; i < 1000; i++ {
    if len(arr) == cap(arr) { // 当容量不足时
        newCap := cap(arr) * 2 // 扩容为原来的2倍
        newArr := make([]int, len(arr), newCap)
        copy(newArr, arr)
        arr = newArr // 更换为新数组
    }
    arr = append(arr, i)
}

3. Erweitern Sie die Obergrenze der Karte

3.1. Schätzen Sie die Anzahl der Elemente

Wir können die Anzahl der Kartenelemente beim Erstellen der Karte schätzen. Dadurch kann die Kapazität des zugrunde liegenden Arrays erhöht und somit die Anzahl der Erweiterungen verringert werden.

m := make(map[int]int, 1000)
// 预估map元素数量为1000

3.2. Kapazität manuell anpassen

Wir können die Kartenkapazität auch manuell anpassen. Wenn die Karte eine große Anzahl von Elementen enthält, können wir die Kapazität der Karte nach bestimmten Regeln erhöhen. In der Standardbibliothek von Golang lautet die Kartenerweiterungsregel: Wenn die Anzahl der Elemente mehr als 2/3 der Größe des zugrunde liegenden Arrays beträgt, wird die Karte auf das Zweifache der ursprünglichen Größe erweitert.

m := make(map[string]int) // 创建空map
for i := 0; i < 10000; i++ {
    key := fmt.Sprintf("key%d", i)
    m[key] = i
    if len(m) >= int(0.67 * float64(cap(m))) { // 当元素数量超过2/3时
        newCap := cap(m) * 2 // 扩容为原来的2倍
        newMap := make(map[string]int, newCap)
        for k, v := range m {
            newMap[k] = v // 复制元素到新map
        }
        m = newMap //更换为新map
    }
}

4. Zusammenfassung

Golang ist eine effiziente Programmiersprache, aber bei der Verarbeitung großer Datenmengen kann Cap zu einem Leistungsengpass werden. Wir können die obige Methode verwenden, um die Obergrenze von Slice und Map zu erweitern und die Programmleistung zu optimieren. Es ist zu beachten, dass die Erweiterung zu einer Neuzuweisung des Speichers und zum Kopieren von Daten führt. Daher sollten die Anzahl der Elemente und die Kapazität geschätzt werden, bevor Elemente hinzugefügt werden.

Das obige ist der detaillierte Inhalt vonSo verlängern Sie die Obergrenze in Golang. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!