分类 Golang 下的文章 - MemoryCloud Blog

Golang的原子属性 lock保证在执行A函数的时候，在A函数执行完毕之前不会执行B函数==锁不能复制，复制后失去原有的效果== lock1 := lock1.lock锁代码块(串行化降低性能)var total int var wg sync.WaitGroup var lock sync.Mutex func add() { defer wg.Done() for i := 0; i < 10000; i++ { lock.Lock() total += 1 lock.Unlock() } } func sub() { defer wg.Done() for i := 0; i < 10000; i++ { lock.Lock() //使用同一把锁 total -= 1 lock.Unlock() //释放锁 } } func main() { wg.Add(2) go add() go sub() wg.Wait() fmt.Println(total) }lock逻辑是，执行lock的代码不会被其他协程影响，其余的协程进入cpu等待func add() { defer wg.Done() for i := 0; i < 3; i++ { lock.Lock() total += 1 fmt.Println("add") lock.Unlock() } } func sub() { defer wg.Done() for i := 0; i < 3; i++ { lock.Lock() total -= 1 fmt.Println("sub") lock.Unlock() } } sub //先执行lock sub sub add add add //等待sub执行结束 02. atomic包原子化var total int32 //必须精准类型 func add() { defer wg.Done() for i := 0; i < 1000; i++ { atomic.AddInt32(&total, 1) } } func sub() { defer wg.Done() for i := 0; i < 1000; i++ { atomic.AddInt32(&total, -1) } } func main() { wg.Add(2) go add() go sub() wg.Wait() fmt.Println(total) } // 03.WMutex的读写锁的本质是将代码串行化，影响性能，==即便设计锁也该尽量保证并行==eg：两组协程，一组负责写数据，一组负责读数据；读协程应该并发，读写之间应该串行，读与读不能并行import ( "fmt" "sync" "time" ) func main() { var num int var rwlock sync.RWMutex var wg sync.WaitGroup wg.Add(2) go func() { //写锁 defer wg.Done() rwlock.Lock() //加写锁，写锁会防止别人的写锁获取，和读锁获取 defer rwlock.Unlock() num = 12 }() time.Sleep(1 * time.Second) //保证写入先执行 go func() { //读锁 defer wg.Done() rwlock.RLock() //加读锁，读锁不会阻止别人的读 defer rwlock.RUnlock() fmt.Println(num) }() wg.Wait() } // 12加写锁会打断读锁func main() { var rwlock sync.RWMutex var wg sync.WaitGroup wg.Add(6) go func() { time.Sleep(time.Second) defer wg.Done() rwlock.Lock() //加写锁，写锁会防止别人的写锁获取，和读锁获取 defer rwlock.Unlock() fmt.Println("Begin Write!") time.Sleep(time.Second * 5) }() for i := 0; i < 5; i++ { go func() { defer wg.Done() for { rwlock.RLock() //加读锁，读锁不会阻止别人的读 time.Sleep(time.Millisecond * 500) fmt.Println("red red red!") rwlock.RUnlock() } }() } wg.Wait() } red red red! red red red! red red red! red red red! red red red! red red red! red red red! red red red! red red red! Begin Write! //暂停读锁

Goroutine多种监控 监控goroutine的执行select类似switch case语句，select的功能和Linux的ip的select、poll、epoll相似。==主要作用于多个channel==eg：有两个goroutine都在执行，在主的gotoutine中，当某一个执行完成后需要立马得到反馈var done bool var lock sync.Mutex func g1() { time.Sleep(time.Second) lock.Lock() defer lock.Unlock() done = true } func g2() { time.Sleep(time.Second * 2) lock.Lock() defer lock.Unlock() done = true } func main() { go g1() go g2() for { if done { fmt.Println("done") time.Sleep(time.Millisecond * 10) return } } }a.select完成多个channel的监控var done = make(chan struct) func g1() { time.Sleep(time.Second) done <- struct } func g2() { time.Sleep(time.Second * 2) done <- struct } func main() { go g1() go g2() <-done fmt.Println("done") //只能知道有goroutine down了但是不知道哪一个 }监控多个不同的goroutine，不使用全局channelselect监控多个channel，每个channel返回都知道。==某一个分支就绪就执行该分支，若果两个都就绪，随机执行==func g1(ch chan struct) { time.Sleep(time.Second * 2) ch <- struct } func g2(ch chan struct) { time.Sleep(time.Second * 1) ch <- struct } func main() { g1ch := make(chan struct) g2ch := make(chan struct) go g1(g1ch) go g2(g2ch) select { case <-g1ch: fmt.Println("g1 down") case <-g2ch: fmt.Println("g2 down") } } g2 down //取决于函数sleepb.select default防止阻塞 select { case <-g1ch: fmt.Println("g1 down") case <-g2ch: fmt.Println("g2 down") default: fmt.Println("default") } //其他函数通常没有执行的机会default设置执行时间 select { case <-g1ch: fmt.Println("g1 down") case <-g2ch: fmt.Println("g2 down") default: time.Sleep(time.Second * 5) //只留给case总共五秒钟时间 fmt.Println("default") }c.Timerfunc g1(ch chan struct) { time.Sleep(time.Second * 2) ch <- struct } func g2(ch chan struct) { time.Sleep(time.Second * 1) ch <- struct } func main() { g1ch := make(chan struct) g2ch := make(chan struct) go g1(g1ch) go g2(g2ch) tm := time.NewTimer(5 * time.Second) //default默认退出时间 for { select { case <-g1ch: fmt.Println("g1 down") case <-g2ch: fmt.Println("g2 down") case <-tm.C: fmt.Println("time out") return //如果不return，循环将继续执行，会导致死锁 } } }

结构体指针 指针初始化直接使用ip是地址，*ip是取值(18)func main() { var ( a int = 18 //声明实际变量 ip *int //声明指针变量 ) ip = &a //把a的地址赋给ip指针 fmt.Println("a变量的值是: ", a) fmt.Println("a变量的地址是: ", &a) fmt.Println("指针ip的值为: ", ip) fmt.Println("指针ip指向的值为: ", *ip) } //输出结果如下 a变量的值是: 18 a变量的地址是: 0xc0000aa058 指针ip的值为: 0xc0000aa058 指针ip指向的值为: 18未取初始化的指针值默认为<nil>func main() { var age *int fmt.Println(age) } <nil>结构体类型指针type Person1 struct { name string } func main() { p := Person1{ "wang", } var po *Person1 = &p fmt.Println(po) } &结构体初始化方法（==指针初始化推荐使用new函数==）//1 func main() { p1 := &Person } //2 func main() { var testPerson Person p2 := &testPerson } //3 func main() { var testPerson = new(Person) fmt.Println(testPerson.name) } 可使用简洁定义func main() { p := Person1{ "wang", } po := &p fmt.Println(po) fmt.Printf("%T", po) } & *main.Person1

结构体绑定方法 结构体绑定方法Go结构体方法没有封装在结构体内部，这样结构体架构很清晰。==通常结构体方法定义在结构体外部，定义函数时绑定结构体。==func (p Person) print() { //关键字 (内部使用名 结构体) 函数名() 返回值 // 接收器(值传递) fmt.Printf("name: %s,age: %d\n", p.name, p.age) } func (p Student) print1() { fmt.Printf("score: %0.2f,name: %s\n", p.score, p.name) }初始化并使用方法；func main() { s := Student{ Person{ "wangtao", 30, }, 560, "jiaobao", } s.print1() } // score: 560.00,name: jiaobao

结构体嵌套 结构体嵌套type Person struct { name string age int } type Student struct { p Person //结构体类型 score float32 } func main() { s := Student{ Person{ "wang", 19, }, 29, } fmt.Println(s.p, s.score) }//s.p.name 29匿名嵌套s.==p==.name 想不走p类型直接取到p的成员变量type Student struct { Person //不写成员变量名字 score float32 } func main() { s := Student{ Person{ "wang", 19, }, 29, } fmt.Println(s.name, s.age) //直接取到Person成员 } wang 19嵌套内部相同的变量名优先级小于嵌套外部type Person struct { name string age int } type Student struct { Person name string } func main() { s := Student{ Person{ "wang", 19, }, "tao", } fmt.Println(s.name) } tao对相同名字的变量赋值或操作 优先使用的是外部结构体的变量。