打包发送
通往管道的数据如果一次打包发送的性能要高于多次发送。请看下面里面，这个里面我往管道里面发送50000000次
func main() {
done,c :=make(chan int),make(chan int ,500)
go func() {
count :=0
for x := range c {
count +=x
}
close(done)
}()
for i :=0 ;i<50000000;i++{
c<-i
}
close(c)
<- done
}
结果如下：
time go run mutilsend.go
1249999975000000
real 0m4.705s
user 0m6.666s
sys 0m1.319s
而当我使用数组打包发送，如下：
package main
func main() {
done,make(chan [500]int ,500)
flag :=0
send :=[500]int{}
go func() {
count :=0
for x := range c {
for _,y :=range x {
count +=y
}
}
println(count)
close(done)
}()
for i :=0 ;i<50000000;i++{
send[flag] = i
if flag ==499 {
flag=0
c<-send
}else{
flag +=1
}
}
close(c)
<- done
}
结果是：
time go run mutilsend.go
1249999975000000
real 0m0.209s
user 0m0.244s
sys 0m0.053s
效率得到了很大的提升。建议搭建在数据量比较大的时候打包发送数据。
锁复制
无论是哪种编程语言，锁对象一定得是公用的，所以的协程是应为共享同一个锁而导致阻塞的，这一点非常重要，下面演示结构体里面使用锁，直接使用会产生锁复制
import (
"sync"
"time"
)
type person struct {
sync.Mutex
}
func (p person) test(act string) {
p.Lock()
defer p.Unlock()
for i:=1;i<10; i++ {
println(act,i)
time.Sleep(time.Millisecond*100)
}
}
func main() {
var p person
var wg sync.WaitGroup
wg.Add(2)
go func() {
defer wg.Done()
p.test("read")
}()
go func() {
defer wg.Done()
p.test("write")
}()
wg.Wait()
}
结果如下：
write 1
read 1
read 2
write 2
write 3
read 3
read 4
write 4
read 5
write 5
write 6
read 6
write 7
read 7
read 8
write 8
write 9
read 9
在write的方法没有释放之前，read就使用了这个test，test这个应该函数是不能被其它地方使用的，这里面问题就在锁复制，如何解决这个问题呢，很简单，指针应用
package main
import (
"sync"
"time"
)
type person struct {
sync.Mutex
}
func (p *person) test(act string) {
p.Lock()
defer p.Unlock()
for i:=1;i<10; i++ {
println(act,i)
time.Sleep(time.Millisecond*100)
}
}
func main() {
var p =new(person)
var wg sync.WaitGroup
wg.Add(2)
go func() {
defer wg.Done()
p.test("read")
}()
go func() {
defer wg.Done()
p.test("write")
}()
wg.Wait()
}
这个里面通过指针的方式避免lock 复制，大家共享同一个锁，看结果
write 1
write 2
write 3
write 4
write 5
write 6
write 7
write 8
write 9
read 1
read 2
read 3
read 4
read 5
read 6
read 7
read 8
read 9
我再上面每次打印睡眠是为了掩饰效果，如果不睡眠，很快执行完毕，很难看到效果。
锁粒度
在加锁的时候请保持一个原则，最小的锁粒度，在能控制的情况下，尽早的释放锁。
譬如上面的例子
func (p *person) test(act string) {
p.Lock()
defer p.Unlock()
for i:=1;i<10; i++ {
println(act,i)
time.Sleep(time.Millisecond*100)
}
}
这里的defer是对整个函数加锁，如果这里设计到多个操作，都在锁范围，如果这里多个操作，有的并不需要加锁，可以减少，如
func (p *person) test(act string) {
d =curl x.x.x.x
p.Lock()
date[i] = d
p.Unlock()
}
上面的请求就没必要加锁，这个在多个调用的时候可以减少等待时间。
死锁
死锁简单的说就是：你等我，我等你。在golang里面重复的加锁也会导致死锁，看下面例子：
package main
import "sync"
func main() {
println("start")
var m sync.Mutex
m.Lock()
m.Lock()
m.Unlock()
m.Unlock()
println("end")
}
结果如下： start fatal error: all goroutines are asleep - deadlock! 死锁了！
