Go语言学习之4 递归&闭包&数组切片&map&锁

主要内容：

1. 内置函数、递归函数、闭包
2. 数组与切片
3. map数据结构
4. package介绍

5. 排序相关

1. 内置函数、递归函数、闭包

1）内置函数

      (1). close：主要用来关闭channel

            1). close函数是一个内建函数，用来关闭channel，这个channel要么是双向的， 要么是只写的（chan<- Type）。
            2). 这个方法应该只由发送者调用， 而不是接收者。
            3). 当最后一个发送的值都被接收者从关闭的channel(下简称为c)中接收时,接下来所有接收的值都会非阻塞直接成功，返回channel元素的零值。

            channel(Go中channel可以是只读、只写、同时可读写的)
            //定义只读的channel
            read_only := make(<-chan int)
            //定义只写的channel
            write_only := make(chan<- int)
            //可同时读写
            read_write := make(chan int)
            定义只读和只写的channel意义不大，一般用于在参数传递中，见代码：

package main

import (
    "fmt"
    "time"
)

func main() {
    c := make(chan int)
    go send(c)
    go recv(c)
    time.Sleep(3 * time.Second) //等待上面执行结束
}
//只能向chan里写数据
func send(c chan<- int) {
    fmt.Println("write data to chan")
    for i := 0; i < 10; i++ {
        c <- i
    }
}
//只能取channel中的数据
func recv(c <-chan int) {
    fmt.Println("read data from chan")
    for i := range c {
        fmt.Println(i)
    }
}

            close函数简介：

1) close函数是一个内建函数， 用来关闭channel，这个channel要么是双向的， 要么是只写的（chan<- Type）。 
2) 这个方法应该只由发送者调用， 而不是接收者。 
3) 当最后一个发送的值都被接收者从关闭的channel(下简称为c)中接收时, 接下来所有接收的值都会非阻塞直接成功，返回channel元素的零值。 

例如如下的代码： 

如果c已经关闭（c中所有值都被接收）， x, ok := <- c， 读取ok将会得到false。

package main

import "fmt"

func main() {
    ch := make(chan int, 5)

    for i := 0; i < 5; i++ {
        ch <- i
    }

    close(ch) // 关闭ch
    for i := 0; i < 10; i++ {
        e, ok := <-ch  //如果c已经关闭（c中所有值都被接收），再次读取 x, ok := <- c， 读取ok将会得到false
        fmt.Printf("%v, %v\n", e, ok)

        if !ok {
            break
        }
    }
}

// 输出结果：
// 0, true
// 1, true
// 2, true
// 3, true
// 4, true
// 0, false

 close函数使用注意事项：

对于值为nil的channel或者对同一个channel重复close,都会panic,关闭只读channel会报编译错误。 

1) 关闭值为nil的通道
var c4 chan int
// 运行时错误：panic: close of nil channel
close(c4)

2) 重复关闭同一个通道
c3 := make(chan int, 1)
close(c3)
// 运行时错误：
// panic: close of closed channel
close(c3)


3) 关闭只读通道
c3 := make(<-chan int, 1)
// 编译错误：
// invalid operation: close(c3) (cannot close receive-only channel)
close(c3)

//正确的用法
c1 := make(chan int, 1) // 双向通道 (bidirectional)
c2 := make(chan<- int, 1) // 只写的 (send-only)
close(c1)
close(c2)

 

     close的详细使用见链接： https://www.jianshu.com/p/d24dfbb33781 

     (2). len：用来求长度，比如string、array、slice、map、channel
     (3). new：用来分配内存，主要用来分配值类型，比如int、struct。返回的是指针
     (4). make：用来分配内存，主要用来分配引用类型，比如chan、map、slice
     (5). append：用来追加元素到数组、slice中

package main

import "fmt"

func main() {
    var a []int
    a = append(a, 10, 20, 30)
    a = append(a, a...)
    fmt.Println(a) //[10 20 30 10 20 30]

    var b []int
    b = make([]int, 5) //存放5个int型数
    b = append(b, 10, 20, 30)
    b = append(b, b...)  
    fmt.Println(b) //b扩容了，[0 0 0 0 0 10 20 30 0 0 0 0 0 10 20 30]
}

     (6). panic和recover：用来做错误处理

panic：
1、内建函数
2、假如函数F中书写了panic语句，会终止其后要执行的代码，在panic所在函数F内如果存在要执行的defer函数列表，按照defer的逆序执行
3、返回函数F的调用者G，在G中，调用函数F语句之后的代码不会执行，假如函数G中存在要执行的defer函数列表，按照defer的逆序执行，这里的defer 有点类似 try-catch-finally 中的 finally
4、直到goroutine整个退出，并报告错误

recover：
1、内建函数
2、用来控制一个goroutine的panicking行为，捕获panic，从而影响应用的行为
3、一般的调用建议
a). 在defer函数中，通过recever来终止一个gojroutine的panicking过程，从而恢复正常代码的执行
b). 可以获取通过panic传递的error

package main

import "fmt"
import "time"
import "errors"

func initConfig() (err error) {
    return errors.New("init config failed")
}

func test() {
    defer func() {
        if err := recover(); err != nil {
            fmt.Println(err)
        }
    }() //执行匿名函数

    err := initConfig()
    if err != nil {
        panic(err) //在该处抛出一个panic的异常，然后在上面的defer中通过recover捕获这个异常，然后正常处理。
    }

    fmt.Println("can not excute") //该行及以下的代码不会被执行
    return
}

func main() {
    for {
        test()
        time.Sleep(time.Second)
    }
}

    总结：go中可以抛出一个panic的异常，然后在defer中通过recover捕获这个异常，然后正常处理。

     (7). new和make的区别
     new 的作用是初始化一个指向类型的指针(*T)，make 的作用是为 slice，map 或 chan 初始化并返回引用(T)。

    例如：

package main

import "fmt"

func test() {

    s1 := new([]int)
    fmt.Println(s1)  //&[]

    s2 := make([]int, 10)
    fmt.Println(s2)  // [0 0 0 0 0 0 0 0 0 0]

    *s1 = make([]int, 5)
    (*s1)[0] = 100
    s2[0] = 100
    fmt.Println(s1)  // &[100 0 0 0 0]
    return
}

func main() {
    test()
}

更详细的区别见链接： https://www.jb51.net/article/126703.htm

2）递归函数

递归定义：一个函数调用自己，就叫做递归。

例1：计算一个数的阶乘

package main

import "fmt"

func calcRecur(n int) int {
    if n == 1 {
        return 1
    }

    return calcRecur(n-1)*n
}

func main() {
    res := calcRecur(5)
    fmt.Println(res) //120
}

例2：计算斐波那契数列

package main

import "fmt"

func calcFib(n int) int {
    if n <= 1 {
        return 1
    }

    return calcFib(n - 1) + calcFib(n - 2)
}

func main() {
    for i := 0; i <= 10; i++ {
        fmt.Println(calcFib(i))
    }
    
}

递归的设计原则：

    1）一个大的问题能够分解成相似的小问题
    2）定义好出口条件

3）闭包

    闭包：一个函数和与其相关的引用环境组合而成的实体。

package main

import "fmt"

func Adder() func(int) int {
    var x int
    return func(delta int) int {
        x += delta
        return x
    } 
} 

func main() {
    var f = Adder()       //x的值，只要Adder()还在调用，则x就在内存中
    fmt.Println(f(1))     //1
    fmt.Println(f(20))    //21 
    fmt.Println(f(300))   //321
} 

package main

import (
    "fmt"
    "strings"
)

//该函数作用检查name是否以suffix结尾，如果不是则追加
func makeSuffixFunc(suffix string) func(string) string {
    return func(name string) string {
        if !strings.HasSuffix(name, suffix) {
            return name + suffix
        }
        return name
    }
}

func main() {
    func1 := makeSuffixFunc(".bmp")
    func2 := makeSuffixFunc(".jpg")
    fmt.Println(func1("test"))  //test.bmp
    fmt.Println(func2("test"))  //test.jpg
}

闭包更多了解详见链接：https://www.cnblogs.com/cxying93/p/6103375.html 和 https://www.cnblogs.com/hzhuxin/p/9199332.html

2. 数组与切片

1.数组

     (1). 数组：是同一种数据类型的固定长度的序列。
     (2). 数组定义：var a [len]int，比如：var a[5]int，一旦定义，长度不能变
     (3). 长度是数组类型的一部分，因此，var a[5] int和var a[10]int是不同的类型
     (4). 数组可以通过下标进行访问，下标是从0开始，最后一个元素下标是：len-1

方法1：
for i := 0; i < len(a); i++ {
}

方法2：
for index, v := range a {
}

     (5). 访问越界，如果下标在数组合法范围之外，则触发访问越界，会panic
     (6). 数组是值类型，因此改变副本的值，不会改变本身的值
           arr2 := arr1
           arr2[2] = 100 //arr1的值不会发生改变

package main

import (
    "fmt"
)

func modify(arr [5]int) { //arr是a的副本
    arr[0] = 100
    return
}

func main() {
    var a [5]int
    
    //var a []int
    //a = make([]int, 5) // cannot use a (type []int) as type [5]int in argument to modify
    
    //modify(a[:]) //cannot use a[:] (type []int) as type [5]int in argument to modify
    modify(a) //a的值不会发生改变
    for i := 0; i < len(a); i++ {
        fmt.Println(a[i])
    }
}

package main

import (
    "fmt"
)

func modify(arr *[5]int) {
    //fmt.Printf("%p\n", arr) //0xc0420481b0
    (*arr)[0] = 100
    (*arr)[1] = 200
    return
}

func main() {
    var a [5]int
    //fmt.Printf("%p\n", &a) //0xc0420481b0
    modify(&a) //a的值改变了
    for i := 0; i < len(a); i++ {
        fmt.Println(a[i])  // a[0]=100  a[1]=200
    }
}

注意下面例子：

package main

import (
    "fmt"
)

func modify(arr [5]int) { //arr是a的副本
    arr[0] = 100
}

func test() {
    var b [5]int = [5]int{1, 2, 3, 4, 5}
    //fmt.Printf("%p\n", &b)
    modify(b)
    fmt.Println(b)  //[1 2 3 4 5] 未改变数组b的值
}

func modifySlice(a []int) {
    fmt.Printf("%p\n", a) //0xc042042440
    a[1] = 1000
}

func testSlice() {
    var b []int = []int{1, 2, 3, 4}
    fmt.Printf("%p\n", b) //0xc042042440
    modifySlice(b) //地址的传递
    fmt.Println(b)  //[1 1000 3 4] 改变了b的值
}

func main() {
    test()
    testSlice()
}

练习：使用非递归的方式实现斐波那契数列，打印前10个数。

package main

import "fmt"

func fab(n int) {
    var a []uint64
    a = make([]uint64, n) //初始化数组 a

    a[0] = 1
    a[1] = 1

    for i := 2; i < n; i++ {
        a[i] = a[i-1] + a[i-2]
    }

    for _, v := range a {
        fmt.Println(v)
    }
}

func main() {
    fab(10)
}

1). 数组初始化

a. var age0 [5]int = [5]int{1,2,3}
b. var age1 = [5]int{1,2,3,4,5}
c. var age2 = […]int{1,2,3,4,5,6}
d. var str = [5]string{3:”hello world”, 4:”tom”}

2). 多维数组

a. var age [5][3]int
b. var f [2][3]int = [...][3]int{{1, 2, 3}, {7, 8, 9}}

3). 多维数组遍历

package main

import (
    "fmt"
)

func main() {

    var f[2][3]int = [...][3]int{{1, 2, 3}, {7, 8, 9}}

    for k1, v1 := range f {
        for k2, v2 := range v1 {
            fmt.Printf("(%d,%d)=%d ", k1, k2, v2)
        }
        fmt.Println()
    }
}

2. 数组切片

(1). 切片：切片是数组的一个引用，因此切片是引用类型
(2).  切片的长度可以改变，因此，切片是一个可变的数组
(3).  切片遍历方式和数组一样，可以用len()求长度
(4).  cap可以求出slice最大的容量，0 <= len(slice) <= cap(array)，其中array是slice引用的数组
(5). 切片的定义：var 变量名 []类型，比如 var str []string, var arr []int

切片引用：
(1). 切片初始化：var slice []int = arr[start:end]包含start到end之间的元素，但不包含end
(2). var slice []int = arr[0:end]可以简写为 var slice []int=arr[:end]
(3). var slice []int = arr[start:len(arr)] 可以简写为 var slice[]int = arr[start:]
(4). var slice []int = arr[0, len(arr)] 可以简写为 var slice[]int = arr[:]
(5). 如果要切片最后一个元素去掉，可以这么写： Slice = slice[:len(slice)-1]

练习：写一个程序，演示切片的各个用法

package main

import (
    "fmt"
)

func main() {
    var slice []int
    var arr [5]int = [...]int{1, 2, 3, 4, 5}
 
    slice = arr[:]
    fmt.Println(slice) //[1 2 3 4 5]
    slice = slice[1:]
    fmt.Println(len(slice)) //4
    slice = slice[:len(slice)-1]
    fmt.Println(cap(slice)) //4

    slice = slice[0:1]
    fmt.Println(len(slice)) //1
    fmt.Println(cap(slice)) //4
}

切片的内存布局：

练习: 写一个程序，演示切片的内存布局（注意和上图的联系）

package main

import "fmt"

//自定义切片类型
type slice struct {
    ptr *[10]int //为了测试方便，定义ptr指向具有固定大小10个字节内存地址
    len int //数组长度
    cap int //数组容量
}

//初始化切片
func make1(s slice, cap int) slice {
    s.ptr = new([10]int)
    s.cap = cap
    s.len = 0
    return s
}

//修改切片内的数组值
func modify(s slice) {
    s.ptr[1] = 1000
}

func testSlice1() {
    var s1 slice
    s1 = make1(s1, 10)

    s1.ptr[0] = 100
    modify(s1)

    fmt.Println(s1.ptr) //&[100 1000 0 0 0 0 0 0 0 0]
}

func modify1(a []int) {
    a[1] = 1000
}

func testSlice2() {
    var b []int = []int{1, 2, 3, 4}
    modify1(b)
    fmt.Println(b) //[1 1000 3 4]
}

func testSlice3() {
    var a = [10]int{1, 2, 3, 4}

    b := a[1:5]
    fmt.Printf("%p\n", b) //0xc042058058
    fmt.Printf("%p\n", &a[1]) //0xc042058058
}

func main() {
    //testSlice1()
    //testSlice2()
    testSlice3()
}

 (6). 通过make来创建切片

var slice []type = make([]type, len)
slice := make([]type, len)
slice := make([]type, len, cap)

(7). 用append内置函数操作切片

slice = append(slice, 10)
var a = []int{1,2,3}
var b = []int{4,5,6}
a = append(a, b…)

(8). For range 遍历切片

for index, val := range slice {}

(9). 切片resize

var a = []int {1,3,4,5}
b := a[1:2]
b = b[0:3]

(10). 切片拷贝

s1 := []int{1,2,3,4,5}
s2 := make([]int, 10)
copy(s2, s1)

s3 := []int{1,2,3}
s3 = append(s3, s2…)
s3 = append(s3, 4, 5, 6)

(11). string与slice

string底层就是一个byte的数组，因此，也可以进行切片操作
str := "hello world"
s1 := str[0:5]
fmt.Println(s1)
s2 := str[5:]
fmt.Println(s2)

(12). string的底层布局

(13). 如何改变string中的字符值？

string本身是不可变的，因此要改变string中字符，需要如下操作：
str := "hello world"
s := []byte(str)
s[0] = 'O'
str = string(s)

(14). 排序和查找操作

排序操作主要都在 sort包中，导入就可以使用了
import("sort")
sort.Ints对整数进行排序，sort.Strings对字符串进行排序, sort.Float64s对
浮点数进行排序.
sort.SearchInts(a []int, b int) 从数组a中查找b，前提是a必须有序
sort.SearchFloats(a []float64, b float64) 从数组a中查找b，前提是a必须有序
sort.SearchStrings(a []string, b string) 从数组a中查找b，前提是a必须有序

package main

import (
    "fmt"
    "sort"
)

func testIntSort() {
    var a = [...]int{1, 8, 38, 2, 348, 484}
    sort.Ints(a[:])

    fmt.Println(a) //[1 2 8 38 348 484]
}

func testStrings() {
    var a = [...]string{"abc", "efg", "b", "A", "eeee"}
    sort.Strings(a[:])

    fmt.Println(a) //[A abc b eeee efg]
}

func testFloat() {
    var a = [...]float64{2.3, 0.8, 28.2, 392342.2, 0.6}
    sort.Float64s(a[:])

    fmt.Println(a) //[0.6 0.8 2.3 28.2 392342.2]
}

func testIntSearch() {
    var a = [...]int{1, 8, 38, 2, 348, 484}
    //sort.Ints(a[:]) 
    index := sort.SearchInts(a[:], 348) //SearchInts该函数内部会先排序然后查找
    fmt.Println(index) //4
    fmt.Println(a) //[1 8 38 2 348 484] 未改变a的值
}

func main() {
    testIntSort()
    testStrings()
    testFloat()
    testIntSearch()
}

注意：sort.Ints，sort.Strings，sort.Float64s会改变源数组的值。

切片，copy及字符串修改测试：

package main

import "fmt"

func testSlice() {
    var a [5]int = [...]int{1, 2, 3, 4, 5}
    s := a[1:]

    fmt.Printf("before len[%d] cap[%d]\n", len(s), cap(s)) //before len[4] cap[4]
    s[1] = 100 //改变s[1](a[1])值
    fmt.Printf("s=%p a[1]=%p\n", s, &a[1]) //s=0xc0420481b8 a[1]=0xc0420481b8
    fmt.Println("before a:", a) //before a: [1 2 100 4 5]

    s = append(s, 10)
    s = append(s, 10)
    fmt.Printf("after len[%d] cap[%d]\n", len(s), cap(s)) //after len[6] cap[8]
    s = append(s, 10)
    s = append(s, 10)
    s = append(s, 10)

    s[1] = 1000 //s扩容之后s和a[1]的地址不同，因此改变s[1]的值a[1]的值不发生变化
    fmt.Println("after a:", a) //after a: [1 2 100 4 5]
    fmt.Println(s) //[2 1000 4 5 10 10 10 10 10]
    fmt.Printf("s=%p a[1]=%p\n", s, &a[1])  //s=0xc042014200 a[1]=0xc0420481b8
}

func testCopy() {
    var a []int = []int{1, 2, 3, 4, 5, 6}
    b := make([]int, 1) 

    copy(b, a) //拷贝的大小以b为准

    fmt.Println(b) //[1]
}

func testString() {
    s := "hello world"
    s1 := s[0:5]
    s2 := s[6:]

    fmt.Println(s1)  //hello
    fmt.Println(s2)  //world
}

func testModifyString() {
    s := "我hello world"
    s1 := []rune(s)

    s1[0] = '你'
    s1[1] = 'z'
    s1[2] = 'z'
    str := string(s1)
    fmt.Println(str)  //你zzllo world
}

func main() {
    //testSlice()
    //testCopy()
    //testString()
    testModifyString()
}

3. map数据结构

(1). map简介
      key-value的数据结构，又叫字典或关联数组
      声明：

      var map1 map[keytype]valuetype
      var a map[string]string
      var a map[string]int
      var a map[int]string
      var a map[string]map[string]string

     注意：声明是不会分配内存的，初始化需要make

(2). map相关操作
     var a map[string]string = map[string]string{"hello": "world"}  定义并初始化map a
     a := make(map[string]string, 10)
     a["hello"] = "world" 插入和更新
     val, ok := a["hello"] 查找
     for k, v := range a {
          fmt.Println(k,v) 遍历
     }

     delete(a, "hello") 删除
     len(a) 长度

(3). map是引用类型
     func modify(a map[string]int) {
          a["one"] = 134
     }

(4). slice of map
     items := make([]map[int][int], 5)
     for i := 0; I < 5; i++ {
           items[i] = make(map[int][int])
     }

(5). map排序
    a. 先获取所有key，把key进行排序
    b. 按照排序好的key，进行遍历

(6). Map反转
    初始化另外一个map，把key、value互换即可

package main

import "fmt"

func testMap() {
    var a map[string]string = map[string]string {
        "key": "value",
    }
    //a := make(map[string]string, 10)
    a["abc"] = "efg"
    a["abc"] = "efg"
    a["abc1"] = "efg"

    fmt.Println(a)  //map[key:value abc:efg abc1:efg]
}

func testMap2() {

    a := make(map[string]map[string]string, 100) //value是一个map
    a["key1"] = make(map[string]string)
    a["key1"]["key2"] = "abc"
    a["key1"]["key3"] = "abc"
    a["key1"]["key4"] = "abc"
    a["key1"]["key5"] = "abc"
    fmt.Println(a)  //map[key1:map[key2:abc key3:abc key4:abc key5:abc]]
}

func modify(a map[string]map[string]string) {
    _, ok := a["zhangsan"]
    if !ok {
        a["zhangsan"] = make(map[string]string)
    }

    a["zhangsan"]["passwd"] = "123456"
    a["zhangsan"]["nickname"] = "pangpang"

    return
}

func testMap3() {

    a := make(map[string]map[string]string, 100)

    modify(a)

    fmt.Println(a) //map[zhangsan:map[passwd:123456 nickname:pangpang]]
}

func trans(a map[string]map[string]string) {
    for k, v := range a {
        fmt.Println(k)
        for k1, v1 := range v {
            fmt.Println("\t", k1, v1)
        }
    }
}

func testMap4() {

    a := make(map[string]map[string]string, 100)
    a["key1"] = make(map[string]string)
    a["key1"]["key2"] = "abc"
    a["key1"]["key3"] = "abc"
    a["key1"]["key4"] = "abc"
    a["key1"]["key5"] = "abc"

    a["key2"] = make(map[string]string)
    a["key2"]["key2"] = "abc"
    a["key2"]["key3"] = "abc"

    trans(a)
    delete(a, "key1") //删除"key1"
    fmt.Println()
    trans(a)

    fmt.Println(len(a))
}

func testMap5() {
    var a []map[int]int
    a = make([]map[int]int, 5)

    if a[0] == nil {
        a[0] = make(map[int]int)
    }
    a[0][10] = 10
    fmt.Println(a)  //[map[10:10] map[] map[] map[] map[]]
}

func main() {
    //testMap()
    //testMap2()
    //testMap3()
    //testMap4()
    testMap5()
}

package main

import (
    "fmt"
    "sort"
)

func testMapSort() {
    var a map[int]int
    a = make(map[int]int, 5)

    a[8] = 10
    a[3] = 10
    a[2] = 10
    a[1] = 10
    a[18] = 10

    var keys []int
    for k, _ := range a {
        keys = append(keys, k)
        //fmt.Println(k, v)
    }

    sort.Ints(keys)

    for _, v := range keys {
        fmt.Println(v, a[v])
    }
 //     1 10
 //     2 10
 //     3 10
 //     8 10
 //    18 10
}

func testMapSort1() {
    var a map[string]int
    var b map[int]string

    a = make(map[string]int, 5)
    b = make(map[int]string, 5)

    a["abc"] = 101
    a["efg"] = 10

    for k, v := range a {
        b[v] = k
    }

    fmt.Println(b)
}

func main() {
    //testMapSort()
    testMapSort1()
}

4. 包

(1). golang中的包
      a. golang目前有150个标准的包，覆盖了几乎所有的基础库
      b. golang.org有所有包的文档，没事都翻翻

(2). 线程同步
      a. import("sync")
      b. 互斥锁, var mu sync.Mutex
      c. 读写锁, var mu sync.RWMutex

1）锁的概念：
     什么是锁呢？就是某个协程（线程）在访问某个资源时先锁住，防止其它协程的访问，等访问完毕解锁后其他协程再来加锁进行访问。

2）互斥锁：

     每个资源都对应于一个可称为 “互斥锁” 的标记，这个标记用来保证在任意时刻，只能有一个协程（线程）访问该资源。其它的协程只能等待。

注意：在使用互斥锁时，一定要注意：对资源操作完成后，一定要解锁，否则会出现流程执行异常，死锁等问题。通常借助defer。锁定后，立即使用defer语句保证互斥锁及时解锁。如下所示：

var mutex sync.Mutex // 定义互斥锁变量 mutex

func write() { 
     mutex.Lock( ) 
     defer mutex.Unlock( ) 
}

3）读写锁：

      互斥锁的问题：互斥锁的本质是当一个goroutine访问的时候，其他goroutine都不能访问。这样在资源同步，避免竞争的同时也降低了程序的并发性能。程序由原来的并行执行变成了串行执行。真正的互斥应该是读取和修改、修改和修改之间，读和读是没有互斥操作的必要的。因此，衍生出另外一种锁，叫做读写锁。因此，读写锁是针对于读写操作的互斥锁。

基本遵循两大原则：
    1、可以随便读。多个goroutin同时读。
    2、写的时候，啥都不能干。不能读，也不能写。

package main

import (
    "fmt"
    "math/rand"
    "sync"
    "sync/atomic"
    "time"
)

var lock sync.Mutex
var rwLock sync.RWMutex

func testMap() {
    var a map[int]int
    a = make(map[int]int, 5)

    a[8] = 10
    a[3] = 10
    a[2] = 10
    a[1] = 10
    a[18] = 10

    for i := 0; i < 2; i++ {
        go func(b map[int]int) {
            lock.Lock()
            b[8] = rand.Intn(100)
            lock.Unlock()
        }(a)
    }

    lock.Lock()
    fmt.Println(a)
    lock.Unlock()

    time.Sleep(time.Second)
}

func testRWLock() {
    var a map[int]int
    a = make(map[int]int, 5)
    var count int32
    a[8] = 10
    a[3] = 10
    a[2] = 10
    a[1] = 10
    a[18] = 10

    for i := 0; i < 2; i++ {
        go func(b map[int]int) {
            //rwLock.Lock()
            lock.Lock()
            b[8] = rand.Intn(100)
            time.Sleep(10 * time.Millisecond)
            lock.Unlock()
            //rwLock.Unlock()
        }(a)
    }

    for i := 0; i < 100; i++ {
        go func(b map[int]int) {
            for {
                lock.Lock()
                //rwLock.RLock()
                time.Sleep(time.Millisecond)
                //fmt.Println(a)
                //rwLock.RUnlock()
                lock.Unlock()
                atomic.AddInt32(&count, 1)
            }
        }(a)
    }
    time.Sleep(time.Second * 3)
    fmt.Println(atomic.LoadInt32(&count))
}

func main() {
    //testMap()
    testRWLock()
}

(3). go get安装第三方包

    go get 可以借助代码管理工具通过远程拉取或更新代码包及其依赖包，并自动完成编译和安装。整个过程就像安装一个 App 一样简单。
    使用 go get 前，需要安装与远程包匹配的代码管理工具，如 Git、SVN、HG 等，参数中需要提供一个包名。

go get+远程包
     默认情况下，go get 可以直接使用。例如，想获取 go 的源码并编译，使用下面的命令行即可：
    $ go get github.com/davyxu/cellnet

    注意：获取前，请确保 GOPATH 已经设置。Go 1.8 版本之后，GOPATH 默认在用户目录的 go 文件夹下。

5. 排序相关

    1）. 实现一个冒泡排序

package main

import "fmt"

func bsort(a []int) {

    for i := 0; i < len(a); i++ {
        for j := 1; j < len(a)-i; j++ {
            if a[j] < a[j-1] {
                a[j], a[j-1] = a[j-1], a[j]
            }
        }
    }
}

func main() {
    b := [...]int{8, 7, 5, 4, 3, 10, 15}
    bsort(b[:])
    fmt.Println(b)
}

    2）. 实现一个选择排序

package main

import "fmt"

func ssort(a []int) {

    for i := 0; i < len(a); i++ {
        var min int = i
        for j := i + 1; j < len(a); j++ {
            if a[min] > a[j] {
                min = j
            }
        }
        a[i], a[min] = a[min], a[i]
    }
}

func main() {
    b := [...]int{8, 7, 5, 4, 3, 10, 15}
    ssort(b[:])
    fmt.Println(b)
}

    3）. 实现一个插入排序

package main

import "fmt"

func isort(a []int) {

    for i := 1; i < len(a); i++ {
        for j := i; j > 0; j-- {
            if a[j] > a[j-1] {
                break
            }
            a[j], a[j-1] = a[j-1], a[j]
        }
    }
}

func main() {
    b := [...]int{8, 7, 5, 4, 3, 10, 15}
    isort(b[:])
    fmt.Println(b)
}

    4）. 实现一个快速排序

package main

import "fmt"

func qsort(a []int, left, right int) {
    if left >= right {
        return
    }

    val := a[left]
    k := left
    //确定val所在的位置
    for i := left + 1; i <= right; i++ {
        if a[i] < val {
            a[k] = a[i]
            a[i] = a[k+1]
            k++
        }
    }

    a[k] = val
    qsort(a, left, k-1)
    qsort(a, k+1, right)
}

func main() {
    b := [...]int{8, 7, 5, 4, 3, 10, 15}
    qsort(b[:], 0, len(b)-1)
    fmt.Println(b)
}

 参考文献：

• https://www.jianshu.com/p/0cbc97bd33fb（Go语言 异常panic和恢复recover用法）
• https://blog.csdn.net/weixin_42927934/article/details/82533940（读写锁、互斥锁）
• http://c.biancheng.net/view/123.html （go get命令——一键获取代码、编译并安装）