互斥体
在前面的例子中，我们看到了如何使用原子操作来管理简单的计数器状态。对于更复杂的状态，可以使用 互斥体 来安全地访问多个 goroutine 中的数据。
在这个例子中，状态（state）是一个映射。示例中的互斥将同步访问状态。我们将跟踪执行的读写操作数量。
这里启动 100 个 goroutine 来对状态执行重复读取，每个 goroutine 中每 ms 读取一次。对于每个读取，我们选择一个键来访问。Lock() 互斥体以确保对状态的独占访问，读取所选键的值， Unlock（） 互斥体，并增加 readOps 计数。
我们还将启动 10 个 goroutine 来模拟写入，使用与读取相同的锁模式。
让 10 个 goroutine 在状态和互斥体上工作一秒钟。采集和报告最终操作计数。手机和报告最终操作计数。用最后的锁状态，显示它是如何结束了。
package main
import (
"sync"
"math/rand"
"sync/atomic"
"time"
"fmt"
)
func main(){
var state = make(map[int]int)
var mutex = &sync.Mutex{}
var readOps uint64 = 0
var writeOps uint64 = 0
for r := 0 ; r < 100 ; r ++{
go func() {
total := 0
for{
key:= rand.Intn(5)
mutex.Lock()
total += state[key]
mutex.Unlock()
atomic.AddUint64(&readOps , 1)
time.Sleep(time.Millisecond)
}
}()
}
for w:= 0 ; w < 10 ; w ++{
go func() {
for{
key := rand.Intn(5)
val := rand.Intn(100)
mutex.Lock()
state[key] = val
mutex.Unlock()
atomic.AddUint64(&writeOps,1)
time.Sleep(time.Millisecond)
}
}()
}
time.Sleep(time.Second)
readOpsFinal := atomic.LoadUint64(&readOps)
fmt.Println("readops:",readOpsFinal)
writeOpsFinal := atomic.LoadUint64(&writeOps)
fmt.Println("writeops",writeOpsFinal)
mutex.Lock()
fmt.Println("state",state)
mutex.Unlock()
}
Go排序实例
Go语言的 sort 包实现了内置和用户定义类型的排序。排序方法特定于内置类型，排序是一个就地排序，不会生成新的切片。
这里举例了一个 int 一个 string 类型的例子。
package main
import (
"sort"
"fmt"
)
func main(){
// example for string
strs := []string{"c","a","b"}
sort.Strings(strs)
fmt.Println("Strings:",strs)
//example of sorting
ints := []int{7,2,4}
sort.Ints(ints)
fmt.Println("Ints: ",ints)
//使用 sort 检查是相关 slice 是否已经被排好序
s := sort.IntsAreSorted(ints)
fmt.Println("sorted: ",s)
}
Go自定义函数
有时候，我们希望通过使用自然排序意外的其他方式对集合进行排序。例如，假设我们想通过字符串长度进行排序，下面是Go语言中自定义排序的类型。
为了使用Go语言中的自定义函数进行排序，我们需要一个相应的类型。这里创建了一个 ByLength 类型，它只是内置 []string 类型的别名。
需要实现 sort.Interface - Len , Less , Swap 在这个类型上，所以可以使用 sort 包中的一般 Sort 函数。 Len 和 Swap 通常在类型之间是相似的， Less 保存实际的自定义排序逻辑。在这个例子中，要按照字符串长度的增加顺序排序，因此在这里使用 len(s[i]) 和 len(s[j])。
所有这些都到位后，现在可以通过将原始 fruits 切片转换为 ByLength 来实现自定义排序，然后对该类型切片使用 sort.Sort() 方法。
package main
import (
"sort"
"fmt"
)
//定义类型
type ByLength []string
//重写下面几个接口函数
func (s ByLength) Len()int{
return len(s)
}
func (s ByLength) Swap(i,j int){
s[i],s[j] = s[j],s[i]
}
func (s ByLength) Less(i,j int) bool {
return len(s[i]) < len(s[j])
}
//正常调用方法
func main(){
fruits := []string{"peach","banana","kiwi"}
sort.Sort(ByLength(fruits))
fmt.Println(fruits)
}
Go panic 错误处理实例
Panic 通常意味着失去出乎意料的错了。大多数情况下，使用他来正常运行时不应该出现的错误，或者不准备妥善处理。
在程序中可使用 Panic 来检查意外的错误。
如果一个函数返回一个我们不知道如何（或想要）处理的错误值，那么 Panic 的常见用法就是终止。这里有一个例子，如果在创建一个新文件时需要意外的错误。
运行此程序将导致程序出错，打印错误消息和 goroutine 跟踪，并退出非零状态。
package main
import "os"
func main(){
panic("a problem")
_,err := os.Create("./test.log")
if err != nil{
panic(err)
}
}
