作者： 一字马胡
转载标志 【2017-11-25】
更新日志
| 日期 | 更新内容 | 备注 |
|---|---|---|
| 2017-11-25 | 新建文章 | go语言入门学习笔记（四） |
golang入门学习笔记系列
golang入门学习笔记（一）
golang入门学习笔记（二）
golang入门学习笔记（三）
Atomic Counters
所谓Atomic，也就是不可中断的操作，下面是go语言中使用Atomic的例子：
// Atomic test
// using nGoroutines goroutines to atomic the counter
// you should sleep some time to test atomic.
func testAtomicCounter(nGoroutines int, counter *int64) {
if nGoroutines == 0 {
nGoroutines = 100 //default goroutines
}
for i := 0; i < nGoroutines; i ++ {
go func() {
for {
//atomic add
atomic.AddInt64(counter, 1)
//no cpu 100%
time.Sleep(time.Millisecond * time.Duration(rand.Intn(1000)))
}
} ()
}
}
var counter int64 = 0
var nGoroutines = 50
testAtomicCounter(nGoroutines, &counter)
//sleep 2 secs to wait the atomic test func
time.Sleep(time.Second * time.Duration(2))
counterCopy := atomic.LoadInt64(&counter)
log.Printf("The Atomic Result:%d", counterCopy)
上面的例子使用多个goroutine来模拟并发竞争，counter是我们维护的计数器。
Mutexes
Mutexes类似于锁，可以使用Mutexes来安全的访问多个goroutine共享的数据，下面是一个使用Mutexes的例子：
//test the Mutexes
//using nGoroutines goroutines to mock ops.
//the share will be ref many goroutines
//the mutext is the "lock"
func testMutexes(nGoroutines int, share *int32, mutex sync.Mutex) {
if nGoroutines == 0 {
nGoroutines = 100
}
for i := 0; i < nGoroutines; i ++ {
go func() {
rdm := rand.Int31n(10)
//lock the share
mutex.Lock()
*share += rdm
//unlock the share
mutex.Unlock()
//no cpu 100%
time.Sleep(time.Second * time.Duration(3))
} ()
}
}
var nGoroutines = 50
var texes = &sync.Mutex{}
var share int32 = 0
testMutexes(nGoroutines, &share, *mutexes)
time.Sleep(time.Second * time.Duration(5))
shareCopy := atomic.LoadInt32(&share)
log.Printf("share:%d\n", shareCopy)
上面的代码使用Mutexes来显示的将多个goroutine共享的share锁住再进行操作。
Stateful Goroutines
除了上面介绍的使用Mutexes来进行多个goroutine同步之外，另一个选择是使用 goroutine 和 channel 内置的同步功能来达到相同的结果，下面是一个例子：
//just test the goroutine "sync" at 2017-11-25 11:13
//
func test201711251113() {
//read op
type readOp struct {
key int
value chan int
}
//write op
type writeOp struct {
key int
value int
res chan bool
}
reads := make(chan *readOp)
writes := make(chan *writeOp)
go func() {
//the share map
var share = make(map[int]int)
for {
select {
case read := <- reads:
read.value <- share[read.key] // read map and send it
case write := <- writes:
key := write.key
value := write.value
share[key] = value
write.res <- true
}
}
} ()
nWrites := 100
nReads := 50
for i := 0; i < nReads; i ++ {
go func() {
for {
read := &readOp{
key:rand.Intn(10),
value:make(chan int),
}
reads <- read
v := <-read.value
log.Printf("read value:%d for key:%d\n", v, read.key)
//no cpu 100%
time.Sleep(time.Millisecond * time.Duration(2000))
}
} ()
}
for i := 0; i < nWrites; i ++ {
go func() {
for {
write := &writeOp{
key:rand.Intn(10),
value:rand.Intn(10),
res:make(chan bool),
}
writes <- write
<- write.res
log.Printf("write value:%d for key:%d\n", write.value, write.key)
//no cpu 100%
time.Sleep(time.Millisecond * time.Duration(2000))
}
} ()
}
//wait some times
time.Sleep(time.Second * time.Duration(3))
}
golang博大精深，还得慢慢学习体会其中的深意啊！
Sort for golang
go对slice支持内置和自定义两种类型的排序，需要注意的是排序是在原来的slice上进行的，而不会生成一个新的slice，下面是一个go语言的sort的使用示例：
//struct of key-value pair
//
type key_value struct {
key int
value int
}
//key-value array
type keyValues []key_value
func (kvs keyValues) Len() int{
return len(kvs)
}
func (kvs keyValues) Swap(i, j int) {
kvs[i], kvs[j] = kvs[j], kvs[i]
}
func (kvs keyValues) Less(i, j int) bool {
kvI := kvs[i]
kvJ := kvs[j]
if (kvI.key == kvJ.key) {
return kvI.value <= kvJ.value
} else {
return kvI.key <= kvJ.key
}
}
//just test the sort of golang
// 2017-11-25 11:33
func testSort() {
orgString := []string {"a", "c", "b", "e", "d"}
sort.Strings(orgString)
fmt.Print(orgString, "\n")
ints := []int {1, 2, 5, 3, 10, 4}
if sort.IntsAreSorted(ints) {
fmt.Print("the ints are sorted!\n")
}
sort.Ints(ints)
fmt.Print(ints, "\n")
kvs := []key_value {
key_value{key:1,value:3},
key_value{key:1,value:2},
key_value{key:2,value:3},
}
sort.Sort(keyValues(kvs))
fmt.Print(kvs, "\n")
}
上面的代码首先根据内置的排序进行排序实验，然后自定义了一种类型，并且对该类型进行自定义排序，排序的规则可以看Less方法的具体实现，如果我们想要实现自定义的排序，就需要实现Sort接口的三个方法，实现之后就可以使用sort方法来进行自定义排序了。
defer for golang
defer类似于java语言中的finally语句块，用于在函数返回之前做一些处理，常用于在函数返回之前做一些资源回收的操作，比如打开的文件资源，需要注意的一点是，当有多个defer的时候，defer的执行是FILO的，也就是说，golang的defer管理使用了栈，先放进去的defer语句将稍后执行，下面的例子是使用golang中的defer的示例：
func tmp(r *int) {
* r += 10
}
func p1() {
fmt.Print("p1\n")
}
func p2() {
fmt.Print("p2\n")
}
func deferTest(i, j int) (r int){
fileName := "/Users/hujian06/github/goLang-demo/goFirst.go";
file, err := os.Open(fileName)
if err!= nil {
panic(err)
}
defer file.Close() // 1 defer
defer tmp(&r) // 2 defer
defer p1()
defer p2()
r = i + j
return r
}
r := deferTest(1, 2)
fmt.Print(r , "\n")
运行上面的代码，结果为13，而且p1和p2的输出顺序为p2->p1，这些结果充分说明了上面的结论，具体的细节可以自己测试一下。
文/一字马胡
