锐客网

  1. 首页 > 生活百科 > it技术 > >

go语言多程需要加锁吗 go语言如何利用多核

IT技术对象

golang sync.pool对象复用 并发原理 缓存池 在go http每一次go serve(l)都会构建Request数据结构 。在大量数据请求或高并发的场景中 ， 频繁创建销毁对象，会导致GC压力 。解决办法之一就是使用对象复用技术 。在http协议层之下，使用对象复用技术创建Request数据结构 。在http协议层之上，可以使用对象复用技术创建(w,*r,ctx)数据结构 。这样即可以回快TCP层读包之后的解析速度，也可也加快请求处理的速度 。
先上一个测试：
结论是这样的：
貌似使用池化，性能弱爆了？？？这似乎与net/http使用sync.pool池化Request来优化性能的选择相违背 。这同时也说明了一个问题，好的东西 ， 如果滥用反而造成了性能成倍的下降 。在看过pool原理之后，结合实例，将给出正确的使用方法 ， 并给出预期的效果 。
sync.Pool是一个 协程安全 的 临时对象池。数据结构如下：
local 成员的真实类型是一个 poolLocal 数组，localSize 是数组长度 。这涉及到Pool实现，pool为每个P分配了一个对象，P数量设置为runtime.GOMAXPROCS(0) 。在并发读写时 ， goroutine绑定的P有对象，先用自己的，没有去偷其它P的 。go语言将数据分散在了各个真正运行的P中，降低了锁竞争 ， 提高了并发能力 。
不要习惯性地误认为New是一个关键字，这里的New是Pool的一个字段 ， 也是一个闭包名称 。其API：
如果不指定New字段，对象池为空时会返回nil，而不是一个新构建的对象 。Get()到的对象是随机的 。
原生sync.Pool的问题是 ， Pool中的对象会被GC清理掉，这使得sync.Pool只适合做简单地对象池，不适合作连接池 。
pool创建时不能指定大小，没有数量限制 。pool中对象会被GC清掉，只存在于两次GC之间 。实现是pool的init方法注册了一个poolCleanup()函数，这个方法在GC之前执行，清空pool中的所有缓存对象 。
为使多协程使用同一个POOL 。最基本的想法就是每个协程 ， 加锁去操作共享的POOL，这显然是低效的 。而进一步改进，类似于ConcurrentHashMap（JDK7）的分Segment，提高其并发性可以一定程度性缓解 。
注意到pool中的对象是无差异性的 ， 加锁或者分段加锁都不是较好的做法 。go的做法是为每一个绑定协程的P都分配一个子池 。每个子池又分为私有池和共享列表 。共享列表是分别存放在各个P之上的共享区域，而不是各个P共享的一块内存 。协程拿自己P里的子池对象不需要加锁，拿共享列表中的就需要加锁了 。
Get对象过程：
Put过程：
如何解决Get最坏情况遍历所有P才获取得对象呢：
方法1止前sync.pool并没有这样的设置 。方法2由于goroutine被分配到哪个P由调度器调度不可控，无法确保其平衡 。
由于不可控的GC导致生命周期过短，且池大小不可控，因而不适合作连接池 。仅适用于增加对象重用机率，减少GC负担 。2
执行结果:
单线程情况下 ， 遍历其它无元素的P，长时间加锁性能低下 。启用协程改善 。
结果：
测试场景在goroutines远大于GOMAXPROCS情况下，与非池化性能差异巨大 。
测试结果
可以看到同样使用*sync.pool，较大池大小的命中率较高，性能远高于空池 。
结论：pool在一定的使用条件下提高并发性能，条件1是协程数远大于GOMAXPROCS，条件2是池中对象远大于GOMAXPROCS 。归结成一个原因就是使对象在各个P中均匀分布 。
池pool和缓存cache的区别 。池的意思是，池内对象是可以互换的，不关心具体值，甚至不需要区分是新建的还是从池中拿出的 。缓存指的是KV映射，缓存里的值互不相同，清除机制更为复杂 。缓存清除算法如LRU、LIRS缓存算法 。
池空间回收的几种方式 。一些是GC前回收 ， 一些是基于时钟或弱引用回收 。最终确定在GC时回收Pool内对象 ， 即不回避GC 。用java的GC解释弱引用 。GC的四种引用：强引用、弱引用、软引用、虚引用 。虚引用即没有引用，弱引用GC但有空间则保留，软引用GC即清除 。ThreadLocal的值为弱引用的例子 。
regexp 包为了保证并发时使用同一个正则，而维护了一组状态机 。
fmt包做字串拼接，从sync.pool拿[]byte对象 。避免频繁构建再GC效率高很多 。
Golang 并发读写map安全问题详解 下面先写一段测试程序，然后看下运行结果：
运行结果：
发生了错误，提示：fatal error: concurrent map read and map write， map 发生了同时读和写了； 但是这个错误并不是每次运行都会出现，就是有的时候会出现，有的时候并不会出现，根据笔者多次运行结果(其他例子 ， 读者可以自己尝试下)来看还会有另外一种报错就是：fatal error: concurrent map writes，就是map发生了同时写，但是只是读是不会有问题的 。关于不同的运行结果小伙伴们可以自己写几个例子去测试下 。下面就这两个错误的发生，笔者给出如下解释：
（1） fatal error: concurrent map read and map write
就是当一个goroutine在写数据，而同时另外一个goroutine要读数据就会报错 ， 不过这个报错也很好理解：还没写完就读，读的数据会有问题，或者反过来还没读完就开始写了，同样会导致读取的数据有问题；
（2） fatal error: concurrent map writes
两个goroutine 同时写一个内存地址，这种操作也是不允许的 ， 会导致一些比较奇怪的问题；
总体来看其实就是写map的操作和其他的读或者写同时发生了，导致的报错 ， 做过几年开发的人可能会想到使用锁来解决，比如写map某个key的时候，通过锁来保证其他goroutine不能再对其写或者读了 。
实现思路：
（1） 当写map的某个key时，通过锁来保证其他goroutine不能再对其写或者读了 。
（2） 当读map的某个key时 ， 通过锁来保证其他的goroutine不能再对其写，但是可以读 。
于是我们马上想到golang 的读写锁貌似符合需求，下面来实现下：
再来看下运行结果：
发现没有报错了，并且多次运行的结果都不会报错，说明这个方法是有用的，不过在go1.9版本后就有sync.Map了，不过这个适用场景是读多写少的场景，如果写很多的话效率比较差 ， 具体的原因在这里笔者就不介绍了，后面会写篇文章详细介绍下 。
今天的文章就到这里了，如果有不对的地方欢迎小伙伴给我留言，看到会即时回复的 。
（十一）golang 内存分析编写过C语言程序的肯定知道通过malloc()方法动态申请内存，其中内存分配器使用的是glibc提供的ptmalloc2 。除了glibc ， 业界比较出名的内存分配器有Google的tcmalloc和Facebook的jemalloc 。二者在避免内存碎片和性能上均比glic有比较大的优势 ， 在多线程环境中效果更明显 。
Golang中也实现了内存分配器 ， 原理与tcmalloc类似，简单的说就是维护一块大的全局内存 ， 每个线程(Golang中为P)维护一块小的私有内存 ， 私有内存不足再从全局申请 。另外，内存分配与GC（垃圾回收）关系密切 ， 所以了解GC前有必要了解内存分配的原理 。
为了方便自主管理内存，做法便是先向系统申请一块内存，然后将内存切割成小块，通过一定的内存分配算法管理内存 。以64位系统为例，Golang程序启动时会向系统申请的内存如下图所示：
预申请的内存划分为spans、bitmap、arena三部分 。其中arena即为所谓的堆区，应用中需要的内存从这里分配 。其中spans和bitmap是为了管理arena区而存在的 。
arena的大小为512G，为了方便管理把arena区域划分成一个个的page，每个page为8KB,一共有512GB/8KB个页；
spans区域存放span的指针，每个指针对应一个page，所以span区域的大小为(512GB/8KB)乘以指针大小8byte = 512M
bitmap区域大小也是通过arena计算出来，不过主要用于GC 。
span是用于管理arena页的关键数据结构，每个span中包含1个或多个连续页，为了满足小对象分配 ， span中的一页会划分更小的粒度 ， 而对于大对象比如超过页大?。蛲ü嘁呈迪?。
根据对象大小，划分了一系列class，每个class都代表一个固定大小的对象，以及每个span的大小 。如下表所示：
上表中每列含义如下：
class： class ID，每个span结构中都有一个class ID, 表示该span可处理的对象类型
bytes/obj：该class代表对象的字节数
bytes/span：每个span占用堆的字节数，也即页数乘以页大小
objects: 每个span可分配的对象个数，也即（bytes/spans）/（bytes/obj）waste
bytes: 每个span产生的内存碎片 ， 也即（bytes/spans）%（bytes/obj）上表可见最大的对象是32K大小 ， 超过32K大小的由特殊的class表示，该class ID为0，每个class只包含一个对象 。
span是内存管理的基本单位,每个span用于管理特定的class对象, 跟据对象大小，span将一个或多个页拆分成多个块进行管理 。src/runtime/mheap.go:mspan定义了其数据结构：
以class 10为例，span和管理的内存如下图所示：
spanclass为10，参照class表可得出npages=1,nelems=56,elemsize为144 。其中startAddr是在span初始化时就指定了某个页的地址 。allocBits指向一个位图，每位代表一个块是否被分配，本例中有两个块已经被分配，其allocCount也为2 。next和prev用于将多个span链接起来，这有利于管理多个span ， 接下来会进行说明 。
有了管理内存的基本单位span ， 还要有个数据结构来管理span ， 这个数据结构叫mcentral ， 各线程需要内存时从mcentral管理的span中申请内存，为了避免多线程申请内存时不断的加锁，Golang为每个线程分配了span的缓存，这个缓存即是cache 。src/runtime/mcache.go:mcache定义了cache的数据结构
alloc为mspan的指针数组，数组大小为class总数的2倍 。数组中每个元素代表了一种class类型的span列表，每种class类型都有两组span列表 ， 第一组列表中所表示的对象中包含了指针 ， 第二组列表中所表示的对象不含有指针，这么做是为了提高GC扫描性能，对于不包含指针的span列表，没必要去扫描 。根据对象是否包含指针，将对象分为noscan和scan两类 ， 其中noscan代表没有指针，而scan则代表有指针，需要GC进行扫描 。mcache和span的对应关系如下图所示：
mchache在初始化时是没有任何span的，在使用过程中会动态的从central中获取并缓存下来，跟据使用情况，每种class的span个数也不相同 。上图所示 ， class 0的span数比class1的要多 ， 说明本线程中分配的小对象要多一些 。
cache作为线程的私有资源为单个线程服务，而central则是全局资源，为多个线程服务，当某个线程内存不足时会向central申请 ， 当某个线程释放内存时又会回收进central 。src/runtime/mcentral.go:mcentral定义了central数据结构：
lock: 线程间互斥锁 ， 防止多线程读写冲突
spanclass : 每个mcentral管理着一组有相同class的span列表
nonempty: 指还有内存可用的span列表
empty: 指没有内存可用的span列表
nmalloc: 指累计分配的对象个数线程从central获取span步骤如下：
将span归还步骤如下：
从mcentral数据结构可见 ， 每个mcentral对象只管理特定的class规格的span 。事实上每种class都会对应一个mcentral,这个mcentral的集合存放于mheap数据结构中 。src/runtime/mheap.go:mheap定义了heap的数据结构：
lock： 互斥锁
spans: 指向spans区域，用于映射span和page的关系
bitmap：bitmap的起始地址
arena_start: arena区域首地址
arena_used: 当前arena已使用区域的最大地址
central: 每种class对应的两个mcentral
从数据结构可见，mheap管理着全部的内存 ， 事实上Golang就是通过一个mheap类型的全局变量进行内存管理的 。mheap内存管理示意图如下：
系统预分配的内存分为spans、bitmap、arean三个区域 ， 通过mheap管理起来 。接下来看内存分配过程 。
针对待分配对象的大小不同有不同的分配逻辑：
(0, 16B) 且不包含指针的对象： Tiny分配
(0, 16B) 包含指针的对象：正常分配
[16B, 32KB] : 正常分配
(32KB, -) : 大对象分配其中Tiny分配和大对象分配都属于内存管理的优化范畴 ， 这里暂时仅关注一般的分配方法 。
以申请size为n的内存为例，分配步骤如下：
Golang内存分配是个相当复杂的过程，其中还掺杂了GC的处理 ， 这里仅仅对其关键数据结构进行了说明，了解其原理而又不至于深陷实现细节 。1、Golang程序启动时申请一大块内存并划分成spans、bitmap、arena区域
2、arena区域按页划分成一个个小块 。
3、span管理一个或多个页 。
4、mcentral管理多个span供线程申请使用
5、mcache作为线程私有资源，资源来源于mcentral 。
用生产者消费者理解golang channel生产者消费者问题是一个著名的线程同步问题，该问题描述如下：有一个生产者在生产产品，这些产品将提供给若干个消费者去消费，为了使生产者和消费者能并发执行，在两者之间设置一个具有多个缓冲区的缓冲池，生产者将它生产的产品放入一个缓冲区中，消费者可以从缓冲区中取走产品进行消费，显然生产者和消费者之间必须保持同步，即不允许消费者到一个空的缓冲区中取产品，也不允许生产者向一个已经放入产品的缓冲区中再次投放产品 。
golang 的channel天生具有这种特性 ， 即
①缓冲区满时写，缓冲区空时读 ， 都会阻塞 。
②channel 本身就是并发安全的 。
golang实现多生产者多消费者：
运行结果：
可以看出，用golang实现生产者消费者非常简单，PV操作不需要各种加锁解锁 ， 奥妙就在于CSP模型，即golang提倡的用通信代替共享内存 。
Go并发编程之美-CAS操作摘要：一、前言 go语言类似Java JUC包也提供了一些列用于多线程之间进行同步的措施，比如低级的同步措施有 锁、CAS、原子变量操作类 。相比Java来说go提供了独特的基于通道的同步措施 。本节我们先来看看go中CAS操作 二、CAS操作 go中的Cas操作与java中类似，都是借用了CPU提供的原子性指令来实现 。
go语言类似Java JUC包也提供了一些列用于多线程之间进行同步的措施，比如低级的同步措施有 锁、CAS、原子变量操作类 。相比Java来说go提供了独特的基于通道的同步措施 。本节我们先来看看go中CAS操作
go中的Cas操作与java中类似 ， 都是借用了CPU提供的原子性指令来实现 。CAS操作修改共享变量时候不需要对共享变量加锁，而是通过类似乐观锁的方式进行检查，本质还是不断的占用CPU 资源换取加锁带来的开销（比如上下文切换开销） 。下面一个例子使用CAS来实现计数器
go中CAS操作具有原子性 ， 在解决多线程操作共享变量安全上可以有效的减少使用锁所带来的开销，但是这是使用cpu资源做交换的 。
我简单列举了并发编程的大纲，需要详细的私信“555”~~
【go语言多程需要加锁吗 go语言如何利用多核】关于go语言多程需要加锁吗和go语言如何利用多核的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息 ， 记得收藏关注本站 。

    推荐阅读


    上一篇：mapreduce输出到hbase，mapreduce inputsplit

    下一篇：钉钉直播屏蔽电脑声音设置，钉钉直播电脑怎么设置关闭自己的声音