08-协程池

最新推荐文章于 2024-08-28 09:01:39 发布
最新推荐文章于 2024-08-28 09:01:39 发布
阅读量1.3k 收藏 19
点赞数 29
分类专栏： Go自研微服务框架 文章标签： golang
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lisus2007/article/details/136203402
版权
本文探讨了Go语言协程池的使用，分析了过多协程可能导致的问题，如内存开销、调度开销增加和系统资源消耗。提出了设计协程池的需求，包括任务队列、超时机制和异常处理，以及如何利用sync.Pool和sync.Cond进行协程管理和协调。
摘要由CSDN通过智能技术生成

协程池

go的优势是高并发，高并发是由go+channel的组合来完成的，那么这里，我们提出一个问题，go协程是否是创建的越多越好？

1. GMP模型

在这里插入图片描述

  • 每个 P 维护一个 G 的本地队列
  • 当一个 G 被创建出来，或者变为可执行状态时，优先把它放到 P 的本地队列中，否则放到全局队列
  • 当一个 G 在 M 里执行结束后，P 会从队列中把该 G 取出；如果此时 P 的队列为空，即没有其他 G 可以执行， M 会先尝试从全局队列寻找 G 来执行，如果全局队列为空，它会随机挑选另外一个 P，从它的队列里拿走一半 G 到自己的队列中执行

**P 的数量在默认情况下，会被设定为 CPU 的核数。而 M 虽然需要跟 P 绑定执行，但数量上并不与 P 相等。这是因为 M 会因为系统调用或者其他事情被阻塞，因此随着程序的执行，M 的数量可能增长，而 P 在没有用户干预的情况下，则会保持不变 **

1.1 大量创建go协程的代价

  • 内存开销

    go协程大约占2k的内存

    src/runtime/runtime2.go

    在这里插入图片描述

  • 调度开销

    虽然go协程的调度开销非常小，但也有一定的开销。

    runntime.Gosched()当前协程主动让出 CPU 去执行另外一个协程

  • gc开销

    协程占用的内存最终需要gc来回收

  • 隐性的CPU开销

    最终协程是要内核线程来执行，我们知道在GMP模型中，G阻塞后，会新创建M来执行，一个M往往对应一个内核线程，当创建大量go协程的时候，内核线程的开销可能也会增大

    GO: runtime: program exceeds 10000-thread limit

​ 在这里插入图片描述

gmp模型中，本地队列的限制是256

  • 资源开销大的任务

    针对资源开销过大的任务，本身也不应当创建大量的协程，以免对CPU造成过大的压力，影响整体上的单机性能

  • 任务堆积

    当创建过多协程，G阻塞增多，本地队列堆积过多，很可能造成内存溢出

  • 系统任务影响

    runtime调度，gc等都是运行在go协程上的，当goroutine规模过大，会影响其他任务

2. 协程池

基于以上一些理由，有必要创建一个协程池，将协程有效的管理起来，不要随意的创建过多的协程。

同时池化的核心在于复用，所以我们可以这么想，一个goroutine是否可以处理多个任务，而不是一个goroutine处理一个任务

2.1 需求

我们先来罗列一下我们的需求：

  1. 希望创建固定数量的协程
  2. 有一个任务队列，等待协程进行调度执行
  3. 协程用完时，其他任务处于等待状态，一旦有协程空余，立即获取任务执行
  4. 协程长时间空余，清理，以免占用空间
  5. 有超时时间，如果一个任务长时间完成不了，就超时，让出协程

2.2 设计

在这里插入图片描述

2.3 初步实现

package mspool

import (
	"errors"
	"sync"
	"sync/atomic"
	"time"
)

type sig struct{}

const DefaultExpire = 3

var (
	ErrorInValidCap    = errors.New("pool cap can not <= 0")
	ErrorInValidExpire = errors.New("pool expire can not <= 0")
	ErrorHasClosed     = errors.New("pool has bean released!!")
)

type Pool struct {
	//cap 容量 pool max cap
	cap int32
	//running 正在运行的worker的数量
	running int32
	//空闲worker
	workers []*Worker
	//expire 过期时间 空闲的worker超过这个时间 回收掉
	expire time.Duration
	//release 释放资源  pool就不能使用了
	release chan sig
	//lock 去保护pool里面的相关资源的安全
	lock sync.Mutex
	//once 释放只能调用一次 不能多次调用
	once sync.Once
}

func NewPool(cap int) (*Pool, error) {
	return NewTimePool(cap, DefaultExpire)
}

func NewTimePool(cap int, expire int) (*Pool, error) {
	if cap <= 0 {
		return nil, ErrorInValidCap
	}
	if expire <= 0 {
		return nil, ErrorInValidExpire
	}
	p := &Pool{
		cap:     int32(cap),
		expire:  time.Duration(expire) * time.Second,
		release: make(chan sig, 1),
	}
	go expireWorker()
	return p, nil
}

func expireWorker() {
	//定时清理过期的空闲worker

}

//提交任务

func (p *Pool) Submit(task func()) error {
	if len(p.release) > 0 {
		return ErrorHasClosed
	}
	//获取池里面的一个worker，然后执行任务就可以了
	w := p.GetWorker()
	w.task <- task
	w.pool.incRunning()
	return nil
}

func (p *Pool) GetWorker() *Worker {
	//1. 目的获取pool里面的worker
	//2. 如果 有空闲的worker 直接获取

	idleWorkers := p.workers
	n := len(idleWorkers) - 1
	if n >= 0 {
		p.lock.Lock()
		w := idleWorkers[n]
		idleWorkers[n] = nil
		p.workers = idleWorkers[:n]
		p.lock.Unlock()
		return w
	}
	//3. 如果没有空闲的worker，要新建一个worker
	if p.running < p.cap {
		//还不够pool的容量，直接新建一个
		w := &Worker{
			pool: p,
			task: make(chan func(), 1),
		}
		w.run()
		return w
	}
	//4. 如果正在运行的workers 如果大于pool容量，阻塞等待，worker释放
	for {
		p.lock.Lock()
		idleWorkers := p.workers
		n := len(idleWorkers) - 1
		if n < 0 {
			p.lock.Unlock()
			continue
		}
		w := idleWorkers[n]
		idleWorkers[n] = nil
		p.workers = idleWorkers[:n]
		p.lock.Unlock()
		return w
	}
}

func (p *Pool) incRunning() {
	atomic.AddInt32(&p.running, 1)
}

func (p *Pool) PutWorker(w *Worker) {
	w.lastTime = time.Now()
	p.lock.Lock()
	p.workers = append(p.workers, w)
	p.lock.Unlock()
}

func (p *Pool) decRunning() {
	atomic.AddInt32(&p.running, -1)
}

func (p *Pool) Release() {
	p.once.Do(func() {
		//只执行一次
		p.lock.Lock()
		workers := p.workers
		for i, w := range workers {
			w.task = nil
			w.pool = nil
			workers[i] = nil
		}
		p.workers = nil
		p.lock.Unlock()
		p.release <- sig{}
	})
}

func (p *Pool) IsClosed() bool {

	return len(p.release) > 0
}

func (p *Pool) Restart() bool {
	if len(p.release) <= 0 {
		return true
	}
	_ = <-p.release
	return true
}


package mspool

import (
	"time"
)

type Worker struct {
	pool *Pool
	//task 任务队列
	task chan func()
	//lastTime 执行任务的最后的时间
	lastTime time.Time
}

func (w *Worker) run() {
	go w.running()
}

func (w *Worker) running() {
	for f := range w.task {
		if f == nil {
			return
		}
		f()
		//任务运行完成，worker空闲
		w.pool.PutWorker(w)
		w.pool.decRunning()
	}
}

2.4 定时清除无用的worker


func (p *Pool) expireWorker() {
	ticker := time.NewTicker(p.expire)
	for range ticker.C {
		currentTime := time.Now()
		if p.IsRelease() {
			break
		}
		p.lock.Lock()
		idleWorkers := p.workers
		n := -1
		for i, w := range idleWorkers {
			if currentTime.Sub(w.lastTime) <= p.expire {
				break
			}
			//需要清除的
			n = i
			w.task <- nil
			idleWorkers[i] = nil
		}
		if n > -1 {
			if n >= len(idleWorkers)-1 {
				p.workers = idleWorkers[:0]
			} else {
				p.workers = idleWorkers[n+1:]
			}
		}
		p.lock.Unlock()
	}
}

2.5 引入sync.pool

在前面我们已经用过pool了，这里我们可以将worker的创建也放入pool中提前暴露（缓存），用的时候从pool中获取，用完在还回pool中，这样性能更高


func (p *Pool) GetWorker() *Worker {
	//1. 目的获取pool里面的worker
	//2. 如果 有空闲的worker 直接获取

	idleWorkers := p.workers
	n := len(idleWorkers) - 1
	if n >= 0 {
		p.lock.Lock()
		w := idleWorkers[n]
		idleWorkers[n] = nil
		p.workers = idleWorkers[:n]
		p.lock.Unlock()
		return w
	}
	//3. 如果没有空闲的worker，要新建一个worker
	if p.running < p.cap {
		//还不够pool的容量，直接新建一个
		c := p.workerCache.Get()
		var w *Worker
		if c == nil {
			w = &Worker{
				pool: p,
				task: make(chan func(), 1),
			}
		} else {
			w = c.(*Worker)
		}

		w.run()
		return w
	}
	//4. 如果正在运行的workers 如果大于pool容量，阻塞等待，worker释放
	for {
		p.lock.Lock()
		idleWorkers := p.workers
		n := len(idleWorkers) - 1
		if n < 0 {
			p.lock.Unlock()
			continue
		}
		w := idleWorkers[n]
		idleWorkers[n] = nil
		p.workers = idleWorkers[:n]
		p.lock.Unlock()
		return w
	}
}

package mspool

import (
	"time"
)

type Worker struct {
	pool *Pool
	//task 任务队列
	task chan func()
	//lastTime 执行任务的最后的时间
	lastTime time.Time
}

func (w *Worker) run() {
	go w.running()
}

func (w *Worker) running() {
	for f := range w.task {
		if f == nil {
			w.pool.workerCache.Put(w)
			return
		}
		f()
		//任务运行完成，worker空闲
		w.pool.PutWorker(w)
		w.pool.decRunning()
	}
}

2.6 引入sync.Cond

sync.Cond 是基于互斥锁/读写锁实现的条件变量，用来协调想要访问共享资源的那些 Goroutine。

当共享资源状态发生变化时，sync.Cond 可以用来通知等待条件发生而阻塞的 Goroutine。

在上述的场景中，我们可以将其应用在等待worker那里，可以使用sync.Cond阻塞，当worker执行完任务后，通知其继续执行。

  • Signal方法：允许调用者Caller唤醒一个等待此Cond和goroutine。如果此时没有等待的goroutine，显然无需通知waiter；如果Cond等待队列中有一个或者多个等待的goroutine，则需要从等待队列中移除第一个goroutine并把它唤醒。在Java语言中，Signal方法也叫做notify方法。调用Signal方法时，不强求你一定要持有c.L的锁。
  • Broadcast方法，允许调用者Caller唤醒所有等待此Cond的goroutine。如果此时没有等待的goroutine，显然无需通知waiter；如果Cond等待队列中有一个或者多个等待的goroutine，则清空所有等待的goroutine，并全部唤醒。在Java语言中，Broadcast方法也被叫做notifyAll方法。同样地，调用Broadcast方法时，也不强求你一定持有c.L的锁。
  • Wait方法，会把调用者Caller放入Cond的等待队列中并阻塞，直到被Signal或者Broadcast的方法从等待队列中移除并唤醒。调用Wait方法时必须要持有c.L的锁。

func (p *Pool) waitIdleWorker() *Worker {
	p.lock.Lock()
	p.cond.Wait()
	fmt.Println("被唤醒")
	idleWorkers := p.workers
	n := len(idleWorkers) - 1
	if n < 0 {
		p.lock.Unlock()
		return p.waitIdleWorker()
	}
	w := idleWorkers[n]
	idleWorkers[n] = nil
	p.workers = idleWorkers[:n]
	p.lock.Unlock()
	return w
}

func NewTimePool(cap int, expire int) (*Pool, error) {
	if cap <= 0 {
		return nil, ErrInvalidCap
	}
	if expire <= 0 {
		return nil, ErrInvalidCap
	}
	p := &Pool{
		cap:     int32(cap),
		expire:  time.Duration(expire) * time.Second,
		release: make(chan sig, 1),
	}
	p.workerCache.New = func() any {
		return &Worker{
			pool: p,
			task: make(chan func(), 1),
		}
	}
	p.cond = sync.NewCond(&p.lock)
	go p.expireWorker()
	return p, nil
}

func (p *Pool) PutWorker(w *Worker) {
	w.lastTime = time.Now()
	p.lock.Lock()
	p.workers = append(p.workers, w)
	p.cond.Signal()
	p.lock.Unlock()
}

2.7 任务超时释放

针对任务超时，需要使用工具的开发者，在程序中自动处理，及时退出goroutine

2.8 异常处理

当task发生问题时，需要能捕获到，对外提供入口，让开发者自定义错误处理方式

package mspool

import (
	msLog "github.com/mszlu521/msgo/log"
	"time"
)

type Worker struct {
	pool *Pool
	//task 任务队列
	task chan func()
	//lastTime 执行任务的最后的时间
	lastTime time.Time
}

func (w *Worker) run() {
	go w.running()
}

func (w *Worker) running() {
	defer func() {
		w.pool.decRunning()
		w.pool.workerCache.Put(w)
		if err := recover(); err != nil {
			//捕获任务发生的panic
			if w.pool.PanicHandler != nil {
				w.pool.PanicHandler()
			} else {
				msLog.Default().Error(err)
			}
		}
		w.pool.cond.Signal()
	}()
	for f := range w.task {
		if f == nil {
			w.pool.workerCache.Put(w)
			return
		}
		f()
		//任务运行完成，worker空闲
		w.pool.PutWorker(w)
		w.pool.decRunning()
	}
}


//PanicHandler
	PanicHandler func(any)


func (p *Pool) waitIdleWorker() *Worker {
	p.lock.Lock()
	p.cond.Wait()

	idleWorkers := p.workers
	n := len(idleWorkers) - 1
	if n < 0 {
		p.lock.Unlock()
		if p.running < p.cap {
			//还不够pool的容量，直接新建一个
			c := p.workerCache.Get()
			var w *Worker
			if c == nil {
				w = &Worker{
					pool: p,
					task: make(chan func(), 1),
				}
			} else {
				w = c.(*Worker)
			}
			w.run()
			return w
		}
		return p.waitIdleWorker()
	}
	w := idleWorkers[n]
	idleWorkers[n] = nil
	p.workers = idleWorkers[:n]
	p.lock.Unlock()
	return w
}

2.9 性能测试

package mspool

import (
	"math"
	"runtime"
	"sync"
	"testing"
	"time"
)

const (
	_   = 1 << (10 * iota)
	KiB // 1024
	MiB // 1048576
	// GiB // 1073741824
	// TiB // 1099511627776             (超过了int32的范围)
	// PiB // 1125899906842624
	// EiB // 1152921504606846976
	// ZiB // 1180591620717411303424    (超过了int64的范围)
	// YiB // 1208925819614629174706176
)

const (
	Param    = 100
	PoolSize = 1000
	TestSize = 10000
	n        = 1000000
)

var curMem uint64

const (
	RunTimes           = 1000000
	BenchParam         = 10
	DefaultExpiredTime = 10 * time.Second
)

func demoFunc() {
	time.Sleep(time.Duration(BenchParam) * time.Millisecond)
}

func TestNoPool(t *testing.T) {
	var wg sync.WaitGroup
	for i := 0; i < n; i++ {
		wg.Add(1)
		go func() {
			demoFunc()
			wg.Done()
		}()
	}

	wg.Wait()
	mem := runtime.MemStats{}
	runtime.ReadMemStats(&mem)
	curMem = mem.TotalAlloc/MiB - curMem
	t.Logf("memory usage:%d MB", curMem)
}

func TestHasPool(t *testing.T) {
	pool, _ := NewPool(math.MaxInt32)
	defer pool.Release()
	var wg sync.WaitGroup
	for i := 0; i < n; i++ {
		wg.Add(1)
		_ = pool.Submit(func() {
			demoFunc()
			wg.Done()
		})
	}
	wg.Wait()

	mem := runtime.MemStats{}
	runtime.ReadMemStats(&mem)
	curMem = mem.TotalAlloc/MiB - curMem
	t.Logf("memory usage:%d MB", curMem)
}

bug修改：


func (p *Pool) expireWorker() {
	//定时清理过期的空闲worker
	ticker := time.NewTicker(p.expire)
	for range ticker.C {
		if p.IsClosed() {
			break
		}
		//循环空闲的workers 如果当前时间和worker的最后运行任务的时间 差值大于expire 进行清理
		p.lock.Lock()
		idleWorkers := p.workers
		n := len(idleWorkers) - 1
		if n >= 0 {
			var clearN = -1
			for i, w := range idleWorkers {
				if time.Now().Sub(w.lastTime) <= p.expire {
					break
				}
				clearN = i
				w.task <- nil
				idleWorkers[i] = nil
			}
			// 3 2
			if clearN != -1 {
				if clearN >= len(idleWorkers)-1 {
					p.workers = idleWorkers[:0]
				} else {
					// len=3 0,1 del 2
					p.workers = idleWorkers[clearN+1:]
				}
				fmt.Printf("清除完成,running:%d, workers:%v \n", p.running, p.workers)
			}
		}
		p.lock.Unlock()
	}
}

er.C {
if p.IsClosed() {
break
}
//循环空闲的workers 如果当前时间和worker的最后运行任务的时间 差值大于expire 进行清理
p.lock.Lock()
idleWorkers := p.workers
n := len(idleWorkers) - 1
if n >= 0 {
var clearN = -1
for i, w := range idleWorkers {
if time.Now().Sub(w.lastTime) <= p.expire {
break
}
clearN = i
w.task <- nil
idleWorkers[i] = nil
}
// 3 2
if clearN != -1 {
if clearN >= len(idleWorkers)-1 {
p.workers = idleWorkers[:0]
} else {
// len=3 0,1 del 2
p.workers = idleWorkers[clearN+1:]
}
fmt.Printf(“清除完成,running:%d, workers:%v \n”, p.running, p.workers)
}
}
p.lock.Unlock()
}
}
lisus2007
关注
专栏目录
python 协程池gevent.pool_python 协程编程之gevent
weixin_33049919的博客
01-28 1094
前言：协程又称微线程，英文名coroutine。协程是用户态的一种轻量级线程，是由用户程序自己控制调度。基于这一原理，协程能在单线程下实现并发。我们知道进程是操作系统分配资源的基本单位，线程是CPU任务调度和执行的最小单位。线程之间的切换是由于线程A遇到了等待操作(比如I/O阻塞)或者计算时间过长，由操作系统控制切换到另一线程B。而协程在遇到阻塞的时候，通过用户程序切换到另一协程，这个切换过程由程...
Python协程的四种实现方式
weixin_45005677的博客
01-08 3167
Python协程的四种实现方式
golang program exceeds 10000-thread limit
jiaolongdy的专栏
08-03 2211
这个问题是因为golang在执行`syscall.Syscall`的时候，会创建新的线程，当并发大的时候不断创建线程，导致线程数超过限制。 建议： 1. 降低系统调用的并发 2. 使用[SetMaxThreads](https://golang.org/pkg/runtime/debug/#SetMaxThreads)增加线程阀值，**但是不建议这样使用**。
git Permission denied (publickey). fatal: Could not read from remote repository.
jiaolongdy的专栏
08-24 910
即使已经在Github中配置了私钥，但是在执行git pull的时候出现如下的错误：Permission denied (publickey). fatal: Could not read from remote repository.这是因为没有将ssh加入到验证ssh-agent中，可以通过以下的方式添加ssh-add -K ~/.ssh/id_rsa完整说明参照官网文档参考：Adding y
如何有效控制 Go 线程数？
梦醒人间
11-30 508
前阵子，在读者交流群中有人提到 Go 默认设置的最大线程数的问题：如果超过一万个 G （挂载于 M 上）阻塞于系统调用，那么程序就会被挂掉。这是对的，因为 Go 对运行时创建的线程数量有一...
Goroutine 数量控制在多少合适，会影响 GC 和调度？
Shanks
03-12 1498
以下内容转载自https://mp.weixin.qq.com/s/uWP2X6iFu7BtwjIv5H55vw 大家好，我是煎鱼。 前几天在读者交流群里看到一位小伙伴，发出了一个致命提问，那就是：“单机的 goroutine 数量控制在多少比较合适？”。 也许你和群内小伙伴第一反应一样，会答复 “控制多少，我觉得没有定论”。 紧接着延伸出了更进一步的疑惑：“goroutine 太多了会影响 gc 和调度吧，主要是怎么预算这个数是合理的呢？” 这是本文要进行探讨的主体，因此本文的结构会是先探索基.
golang实现协程池
江南孟浪生的博客
08-03 462
go协程池可以看成一个被初始化的固定大小的协程循环读取函数队列，获取是否有可供调用的函数队列，如果有，则协程池中的一个协程调用并执行该函数，talk is cheap,show me the code。好了，整体代码介绍完了，希望你能对协程池有个比较简单的了解，也可以基于此代码，丰富一下逻辑。测试用的代码如下所示。
Kotlin 协程 - 协程启动篇
pureChilder的博客
07-23 567
java初转kotlin 启动线程的写法： val myThread = thread { //do what you want } 这个 thread 方法有个参数 start 默认为 true，换句话说，这样创造出来的线程默认就是启动的，除非你实在不想让它马上投入工作： val myThread = thread(start = false) { //do what you want } //later on … myThread.start() 协程的启动其实与上面写的thead启动有相似的地
python 协程池,python 多进程池、多线程池、协程池 实现笔记
weixin_32329059的博客
03-25 277
进程：一个运行的程序(代码)就是一个进程，没有运行的代码叫程序，进程是系统资源分配的最小单位，进程拥有自己独立的内存空间，所有进程间数据不共享，开销大。线程: cpu调度执行的最小单位，也叫执行路径，不能独立存在，依赖进程存在，一个进程至少有一个线程，叫主线程，而多个线程共享内存可以极大地提高了程序的运行效率。协程: 是一种用户态的轻量级线程，协程的调度完全由用户控制，协程拥有自己的寄存器上下文和...
Python 彻底解读协程与异步【看完包会】
浪子燕青的博客
10-21 3498
title: Python 协程与异步 copyright: true top: 0 date: 2018-08-11 10:15:50 tags: categories: Python进阶笔记 permalink: password: keywords: 协程 description: Python2.7中用代码实现协程，同时区分同步与异步，以及异步的表现形式，回调与协程。 像烟花也是过一生，...
如何在EasySwoole框架中使用协程
EasySwoole在底层基于Swoole扩展，提供了对协程的全面支持，通过协程可以实现高性能的并发处理，更好地利用服务器资源。 #### 1.3 本文要讨论的内容 本文将深入探讨EasySwoole框架中协程的基本概念、使用方法，...
Unity3D使用WWW类和协程完成图片、视频下载播放
逆袭的博客
07-22 1258
今天讲解一下如何使用WWW类和协程完成简单的图片和视频下载播放功能。 一、WWW类 WWW是一个Unity开发中非常常用到的工具类，主要提供一般Http访问的功能，以及动态从网上下载图片、声音、视频、Unity资源等。 注意：iPhone支持http://， https://和 file://协议；ftp://协议的支持仅限于匿名下载。其他协议不被支持。 当在windows和Windows
项目管理实践【三】每日构建【Daily Build Using CruiseControl.NET and MSBuild】
jiaolongdy的专栏
02-10 847
<br /><br />在上一篇项目管理实践教程二、源代码控制【Source Control Using VisualSVN Server and TortoiseSVN】中我们已经讲解了如何使用TortoiseSVN和VisualSVN Server来做简单的版本控制，这一篇我们将会讲解使用CruiseControl.NET和MSBuild来搭建每日构建系统。<br />在第一篇项目管理实践教程一、工欲善其事，必先利其器【Basic Tools】 中我们已经安装了CruiseControl.NET 1.4
Go反射四讲---第四讲：如何使用反射遍历字符串，切片，数组和Map呢？
weixin_55818116的博客
08-26 333
反射四讲，最后一讲，如何使用遍历字符串，切片，数组和map等，反射总结以及一个简单的反射实战项目
一文掌握 Go 内存对齐
newbietao的博客
08-23 976
例如，对于一个 32 位的整数，如果存储在非 4 字节对齐的地址上，可能需要两次内存读取操作才能获取完整的数据，而在对齐的地址上，一次读取操作即可。内存对齐是一种将数据在内存中进行排列的方式，目的是提高内存访问的效率和保证数据的完整性。数据的内存排列方式最直观的体现就是数据的内存地址，说白了就是数据的内存地址要符合一定规则，以便于CPU读取，这个规则就是下面要讲的内存对齐规则。上面的输出和我们的结论是契合的，内存地址都是对齐值的倍数，另外还有一点，为了减少内存开销，编译器还会优化内存布局，减少内存碎片。
Golang测试func TestXX(t *testing.T)的使用
席万里的博客
08-25 444
Golang测试
第一个go程序
最新发布
zhourongxiang1的博客
08-28 109
hello.go所在目录。
goland协程池
06-01
好的，关于golang协程池，我可以给您一些解释和建议。 首先，协程池可以提高程序的效率，减少创建和销毁协程的开销。在golang中，可以使用sync包中的WaitGroup和Pool来实现协程池的功能。 WaitGroup可以用来等待一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值