Go语言使用make进行内存分配的代码示例

目录

• make 函数的基本概念
• 语法与适用类型
• 代码示例
• 切片的 make 分配
• 长度与容量的区别
• 项目场景：数据处理
• 映射的 make 分配
• 初始容量的作用
• 项目场景：缓存系统
• 通道的 make 分配
• 有缓冲通道与无缓冲通道
• 项目场景：并发任务处理
• 总结

make 函数的基本概念

语法与适用类型

make 函数的语法格式为 make(T, args)，其中 T 代表要创建的类型，必须是切片、映射或通道这三种引用类型之一，args 是根据不同类型而定的参数。以下是三种类型使用 make 函数的基本形式：

• 切片：make([]T, length, capacity)，其中 T 是切片元素的类型，length 是切片的初始长度，capacity 是切片的初始容量（可省略，默认与长度相同）。
• 映射：make(map[K]V, initialCapacity)，K 是键的类型，V 是值的类型，initialCapacity 是映射的初始容量（可省略）。
• 通道：make(chan T, bufferSize)，T 是通道中元素的类型，bufferSize 是通道的缓冲区大小（可省略，省略时为无缓冲通道）。

代码示例

package main

import "fmt"

func main() {
    // 使用 make 创建切片
    slice := make([]int, 3, 5)
    fmt.Printf("切片长度: %d, 容量: %d, 内容: %v\n", len(slice), cap(slice), slice)

    // 使用 make 创建映射
    m := make(map[string]int)
    m["apple"] = 1
    m["ba编程客栈nana"] = 2
    fmt.Println("映射内容:", m)

    // 使用 make 创建通道
    ch := make(chan int, 2)
    ch <- 10
    ch <- 20
    fmt.Println("从通道接收:", <-ch)
}

在上述代码中，分别使用 make 函数创建了切片、映射和通道，并进行了简单的操作。

切片的 make 分配

长度与容量的区别

在使用 make 创建切片时，长度和容量是两个重要的概念。长度表示切片中当前元素的数量，而容量表示切片底层数组的大小。可以通过 len() 函数获取切片的长度，通过 cap() 函数获取切片的容量。

package main

import "fmt"

func main() {
    // 创建一个长度为 2，容量为 5 的切片
    slice := make([]int, 2, 5)
    fmt.Printf("初始长度: %d, 初始容量: %d\n", len(slice), cap(slice))

    // 向切片追加元素
    slice = append(slice, 1, 2, 3)
    fmt.Printf("追加元素后长度: %d, 容量: %d, 内容: %v\n", len(slice), cap(slice), slice)
}

在这个示例中，初始创建的切片长度为 2，容量为 5。当使用 append 函数追加元素时，如果长度超过了容量，Go 语言会自动重新分配更大的底层数组。

项目场景：数据处理

在数据处理项目中，我们可能需要动态地处理一批数据。使用 make 创建切片可以预先分配一定的容量，减少内存重新分配的次数，提高性能。

package main

import (
    "fmt"
)

func processData() []int {
    // 预先分配容量为 100 的切片
    data := make([]int, 0, 100)
    for i := 0; i < 100; i++ {
        data = append(data, i)
    }
    return data
}

func main() {
    result := processData()
    fmt.Println("处理后的数据:", result)
}

映射的 make 分配

初始容量的作用

在使用 makejs 创建映射时，指定初始容量可以提高映射的性能。如果预先知道映射可能存储的元素数量，指定合适的初始容量可以减少哈希表扩容的次数。

package main

import "fmt"

func main() {
    // 创建一个初始容量为 10 的映射
    m := make(map[string]int, 10)
    for i := 0; i < 10; i++ {python
        key := fmt.Sprintf("key%d", i)
        m[key] = i
    }
    fmt.Println("映射内容:", m)
}

项目场景：缓存系统

在缓存系统中，映射可以用于存储缓存数据。使用 make 创建映射并指定合适的初始容量，可以提高缓存系统的性能。

package main

import (
    "fmt"
)

type Cache struct {
    data map[string]interface{}
}

func NewCache(capacity int) *Cache {
    return &Cache{
        data: make(map[string]interface{}, capacity),
    }
}

func (c *Cache) Set(key string, value interface{}) {
    c.data[key] = value
}

func (c *Cache) Get(key string) (interface{}, bool) {
    val, exists := c.data[key]
    return val, exists
}

func main() {
    cache := NewCache(20)
    cache.Set("item1", 100)
    val, exists := cache.Get("item1")
    if exists {
        fmt.Println("缓存中获取的值:", val)
    }
}

通道的 make 分配

有缓冲通道与无缓冲通道

使用 make 创建通道时，可以指定缓冲区大小。如果不指定缓冲区大小，创建的是无缓冲通道，发送和接收操作会阻塞；如果指定了缓冲区大小，创建的是有缓冲通道，只有当缓冲区满时发送操作才会阻塞，只有当缓冲区为空时接收操作才会阻塞。

package main

import "fmt"

func main() {
    // 创建无缓冲通道
    ch1 := make(chan int)
    go func() {
        ch1 <- 10
        fmt.Println("数据已发送到无缓冲通道")
    }()
    fmt.Println("从无缓冲通道接收:", <-ch1)

    // 创建有缓冲通道
    ch2 := make(chan int, 2)
    ch2 <- 20
    ch2 <- 30
    fmt.Println("从有缓冲通道接收:", <-ch2)
}

项目场景：并发任务处理

在并发任务处理中，通道可以用于协程之间的通信。使用 make 创建合适的通道可以协调不同协程的工作。

package main

import (
    "fmt"
)

func worker(id int, jobs <-chan int, results chan<- int) {
    for j := range jobs {
        fmt.Printf("Worker %d 开始处理任务 %d\n", id, j)
        results <- j * 2
    }
}

func main() {
    const numJobs = 5
    jobs := make(chan int, numJobs)
    results := make(chan int, numJobs)

    // 启动 3 个工作协程
    for w := 1; w <= 3; w++ {
        go worker(w, jobs, results)
    }

    // 发送任务
    for j := 1; j <= numJobs; j++ {
        jobs <- j
    }
    close(jobs)

    // 收集结果
    for a := 1; a <= numJobs; a++ {
        <-results
    }
    close(results)
}

总结

make 函数在 Go 语言中是为切片、映射和通道进行内存分配和初始化的重要工具。通过合理使用 make 函数，可以根据不同的需求为这些引用类型分配合适的内存，提高程序的性能和效率。在实际项目中，无论是数据处理、缓存系统还是并发任务处理，make 函数都发挥着关键作用。开发者需要深入理解 make 函数的使用方法和不同类型的特点，根据具体的场景灵活运用。

以上就是Go语言使用make进行内存分配的代码示例的详细内容，更多关于Go make内存分配的资料请关注编程客栈(www.cppcnwww.devze.coms.cjsom)其它相关文章！