Petua pengoptimuman prestasi fungsi Golang

Prestasi fungsi Go boleh dioptimumkan dengan petua berikut: Gunakan caching untuk mengelakkan pengiraan berganda. Gunakan goroutine untuk menggabungkan pengiraan untuk meningkatkan kecekapan. Gunakan kod pemasangan untuk pengiraan kritikal untuk meningkatkan prestasi. Pilih struktur data yang sesuai seperti kepingan, peta dan saluran untuk mengoptimumkan penyimpanan dan pengambilan data. Elakkan peruntukan memori yang tidak perlu untuk mengurangkan overhed prestasi. Fungsi yang sering dipanggil sebaris untuk mengurangkan overhed panggilan.

Go petua pengoptimuman prestasi fungsi

Pengenalan

Go ialah bahasa dengan prestasi cemerlang, tetapi kecekapannya boleh dipertingkatkan lagi dengan mengoptimumkan fungsi. Artikel ini menerangkan beberapa petua praktikal untuk membantu anda meningkatkan prestasi fungsi Go anda.

1. Gunakan cache

Untuk nilai yang kerap dikira, menggunakan cache boleh mengelakkan pengiraan berulang. Go menyediakan jenis penyegerakan/Peta, yang merupakan cache selamat dan cekap serentak.

Contoh:

import (
    "sync"
)

var cache = sync.Map{}

func GetValue(key int) int {
    value, ok := cache.Load(key)
    if ok {
        return value.(int)
    }

    value = calculateValue(key)
    cache.Store(key, value)
    return value
}

2. Concurrency

Go mesra concurrency, yang bermaksud anda boleh menggunakan goroutine untuk meningkatkan prestasi fungsi. Apabila menggunakan goroutin, cuma pastikan anda mempunyai kawalan serentak yang sesuai, seperti menggunakan penyegerakan.Mutex atau saluran.

Contoh:

func CalculateSum(numbers []int) int {
    ch := make(chan int)
    defer close(ch)

    for _, num := range numbers {
        go func(num int) {
            ch <- num
        }(num)
    }

    sum := 0
    for val := range ch {
        sum += val
    }
    return sum
}

3. Gunakan pemasangan

Untuk fungsi intensif pengiraan kritikal, menggunakan pemasangan boleh meningkatkan prestasi dengan ketara. Go menyediakan pakej pemasangan yang membolehkan anda membenamkan kod pemasangan sebaris dalam kod Go anda.

Contoh:

//go:noinline
func Fibonacci(n int) int {
    if n <= 1 {
        return 1
    }

    return Fibonacci(n-1) + Fibonacci(n-2)
}

//go:nosplit
func FibonacciAsm(n int) int {
    switch {
    case n <= 1:
        return 1
    case n&1 == 0:
        return FibonacciAsm(n>>1) * FibonacciAsm(n>>1)
    default:
        return FibonacciAsm(n>>1) * FibonacciAsm(n>>1+1)
    }
}

4. Pengoptimuman struktur data

Memilih struktur data yang sesuai adalah penting untuk prestasi. Go menyediakan set struktur data terbina dalam yang kaya seperti kepingan, peta dan saluran. Pilih struktur yang paling sesuai dengan kes penggunaan anda.

Contoh:

Untuk menyimpan dan mendapatkan semula sejumlah besar elemen, slice ialah pilihan yang cekap. peta berguna untuk mencari pasangan nilai kunci dengan cepat. saluran digunakan untuk komunikasi serentak.

5. Elakkan peruntukan yang tidak perlu

Setiap kali program memperuntukkan memori timbunan, ia menyebabkan overhed prestasi. Elakkan peruntukan yang tidak perlu seperti penimbal praperuntukan atau menggunakan semula kepingan sedia ada.

Contoh:

func ConcatenateStrings(ss []string) string {
    b := make([]byte, 0, len(ss)*10) // 预分配缓冲区
    for _, s := range ss {
        b = append(b, s...)
    }
    return string(b)
}

6. Fungsi sebaris

Untuk fungsi yang sering dipanggil, sebaris boleh mengurangkan overhed panggilan. Pengkompil Go secara automatik menyelaraskan fungsi kecil, tetapi anda juga boleh menggunakan sintaks arahan sebaris untuk memaksa sebaris.

Contoh:

//go:inline
func Abs(x int) int {
    if x < 0 {
        return -x
    }
    return x
}

Kes praktikal

Katakan kita mempunyai fungsi CalculateFactorial yang digunakan untuk mengira faktorial nombor. Kami boleh menggunakan pengoptimuman ini untuk meningkatkan prestasi fungsi: CalculateFactorial，用于计算一个数字的阶乘。我们可以应用这些优化来提高函数的性能：

• 使用缓存：

  • 缓存以前计算的阶乘值，以避免重复计算。

• 并发化：

  • 将阶乘计算分解为 goroutine，提高并发性。

• 使用汇编：

  • 对于大型数字，使用汇编代码优化阶乘计算循环。

优化后的代码：

import (
    "fmt"
    "sync"
    "runtime"
)

var factorialCache = sync.Map{}

func CalculateFactorial(n int) int {
    if n <= 1 {
        return 1
    }

    value, ok := factorialCache.Load(n)
    if ok {
        return value.(int)
    }

    numCores := runtime.NumCPU()
    ch := make(chan int, numCores)
    defer close(ch)

    for i := 0; i < n; i++ {
        go func(num int) {
            ch <- num
        }(i)
    }

    var partialFactorial int64 = 1
    for val := range ch {
        partialFactorial *= int64(val)
    }

    factorial := int(partialFactorial)
    factorialCache.Store(n, factorial)
    return factorial
}

func main() {
    result := CalculateFactorial(20)
    fmt.Println(result)
}

通过应用这些优化，我们可以显著提高 CalculateFactorial

• 🎜Gunakan caching: 🎜🎜
  • Cache nilai faktorial yang dikira sebelum ini untuk mengelakkan pengiraan berulang.
• 🎜🎜Concurrency: 🎜🎜
  • Uraikan pengiraan faktorial menjadi goroutin untuk menambah baik concurrency.
• 🎜🎜Gunakan pemasangan: 🎜🎜
  • Untuk nombor yang besar, gunakan kod pemasangan untuk mengoptimumkan gelung pengiraan faktorial.

🎜🎜Kod dioptimumkan: 🎜🎜rrreee🎜Dengan menggunakan pengoptimuman ini, kami boleh meningkatkan prestasi fungsi CalculateFactorial dengan ketara, terutamanya untuk bilangan yang besar. 🎜

Atas ialah kandungan terperinci Petua pengoptimuman prestasi fungsi Golang. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!