文章目录
1.并发
Go语言通过编译器运行时（runtime），从语言上支持了并发的特性。Go语言的并发通过goroutine特性完成。
goroutine类似于线程，但是可以根据需要创建多个goroutine并发工作。goroutine是由Go语言的运行时调度完成，而线程是由操作系统调度完成。
1.1 创建goroutine
func main() {
go func() {
for i := 0; i < 100; i++ {
fmt.Println("hello",i)
}
}()
for i := 0; i < 100; i++ {
fmt.Println("nihao",i)
}
}
以上采用匿名函数的方式，也可采用函数的方式，略
1.2 Go语言的协作程序（goroutine）和普通的协作程序（coroutine）
● goroutine可能发生并行执行；但coroutine始终顺序执行。
狭义地说，goroutine可能发生在多线程环境下，goroutine无法控制自己获取高优先度支持；coroutine始终发生在单线程，coroutine程序需要主动交出控制权，宿主才能获得控制权并将控制权交给其他coroutine。
● goroutine间使用channel通信；coroutine使用yield和resume操作。
1.3 goroutine间的通信（channel）
Go语言中的通道（channel）是一种特殊的类型。在任何时候，同时只能有一个goroutine访问通道进行发送和获取数据。goroutine间通过通道就可以通信。就好比一个阻塞队列。
func main() {
ch1 := make(chan int) //创建存放int型的通道
ch2 := make(chan interface{}) //创建一个空接口类型的通道
ch3 :=make(chan *Student) //创建Student结构体指针类型的通道
}
1.3.1 使用通道发送数据
通道的发送使用特殊的操作符“<-”
通道变量 <- 值
- 通道变量：通过make创建好的通道实例。
- 值：可以是变量、常量、表达式或者函数返回值等。值的类型必须与ch通道的元素类型一致。
ch := make(chan interface{}) //创建一个空接口类型的通道
ch <- 111
ch <- "wowouwo"
运行时发现所有的goroutine（包括main）都处于等待goroutine。也就是说所有goroutine中的channel并没有形成发送和接收对应的代码。
1.3.2 使用通道接收数据
- 通道的收发操作在不同的两个goroutine间进行。
- 接收将持续阻塞直到发送方发送数据。
- 每次接收一个元素。
data := <-ch //阻塞接受
data, ok := <-ch //非阻塞接受 ok代表是否接收到数据
<- ch // 忽略接受
//执行该语句时将会发生阻塞，直到接收到数据，但接收到的数据会被忽略。
//这个方式实际上只是通过通道在goroutine间阻塞收发实现并发同步。
循环接收
for data:=range ch{
}
通道ch是可以进行遍历的，遍历的结果就是接收到的数据。数据类型就是通道的数据类型。通过for遍历获得的变量只有一个。
func printer(c chan int) {
for {
data := <-c
if data == 0 {
break
}
fmt.Println(data)
}
c <- 0
}
func main() {
c := make(chan int)
go printer(c)
for i := 1; i <= 10; i++ {
c <- i
}
c <- 0
//等待结束
<-c
fmt.Println("结束")
}
单向通道
只能发送的通道类型为chan<-，只能接收的通道类型为<-chan
func main() {
ch := make(chan int)
var chSendOnly chan<- int = ch
data := <-chSendOnly
fmt.Println(data)
}
ch := make(chan int)
//var chSendOnly chan<- int = ch
//data := <-chSendOnly
//fmt.Println(data)
var chReadOnly <-chan int = ch
<-chReadOnly
带缓冲的通道
1.3.3 通道的多路复用
Go语言中提供了select关键字，可以同时响应多个通道的操作。select的每个case都会对应一个通道的收发过程。当收发完成时，就会触发case中响应的语句。多个操作在每次select中挑选一个进行响应。
func RPCClient(ch chan string, req string) (string, error) {
ch <- req
//等待服务器返回
select {
case ack := <-ch:
return ack, nil
case <-time.After(time.Second):
return "", errors.New("超时")
}
}
func RPCServer(ch chan string) {
for {
data := <-ch
fmt.Println("接收到：" + data)
ch <- "had receive"
}
}
func main() {
ch := make(chan string)
go RPCServer(ch)
ack, err :=
RPCClient(ch, "hello")
fmt.Println(ack, err)
}
1.4 同步(lock)
通道内部的实现依然使用了各种锁，因此优雅代码的代价是性能。在某些轻量级的场合，原子访问（atomic包）、互斥锁（sync.Mutex）以及等待组（sync.Wait Group）能最大程度满足需求。
其中介绍等待组：
等待组内部拥有一个计数器，计数器的值可以通过方法调用实现计数器的增加和减少。当我们添加了N个并发任务进行工作时，就将等待组的计数器值增加N。每个任务完成时，这个值减1。同时，在另外一个goroutine中等待这个等待组的计数器值为0时，表示所有任务已经完成。
原子操作：
func main() {
var c int32
wg := sync.WaitGroup{}
//开启100个goroutine
for i := 0; i < 100; i++ {
wg.Add(1)
go func() {
defer wg.Done()
tmp := atomic.LoadInt32(&c)
if !atomic.CompareAndSwapInt32(&c, tmp, tmp+1) {
fmt.Println("c 修改失败")
}
}()
}
wg.Wait()
//c的值有可能不等于100，频繁修改变量值情况下，CompareAndSwap操作有可能不成功。
fmt.Println("c : ", c)
}
lock：
需要注意的就是：
lock.Lock()
defer lock.Unlock()
var count int
var lock sync.Mutex
var arthmatic sync.WaitGroup
Increment := func() {
lock.Lock()
defer lock.Unlock()
count++
fmt.Printf("Incrementing: %d\n", count)
}
Decrement := func() {
lock.Lock()
defer lock.Unlock()
count--
fmt.Printf("Decrementing: %d\n", count)
}
for i := 0; i < 5; i++ {
arthmatic.Add(1)
go func() {
defer arthmatic.Done()
Increment()
}()
}
for i := 0; i < 5; i++ {
arthmatic.Add(1)
go func() {
defer arthmatic.Done()
Decrement()
}()
}
arthmatic.Wait()
fmt.Printf("Arthmatic completed!\n")
2. 反射
**反射是指在程序运行期对程序本身进行访问和修改的能力。**程序在编译时，变量被转换为内存地址，变量名不会被编译器写入到可执行部分。在运行程序时，程序无法获取自身的信息。支持反射的语言可以在程序编译期将变量的反射信息，如字段名称、类型信息、结构体信息等整合到可执行文件中，并给程序提供接口访问反射信息，这样就可以在程序运行期获取类型的反射信息，并且有能力修改它们。
修改值:
var num int = 10
rVal := reflect.ValueOf(&num)
fmt.Printf("%v\n", rVal.Kind())
rVal.Elem().SetInt(1)
报错
var str string = "ok"
rval := reflect.ValueOf(str)
rval.SetString("oooo")
fmt.Printf(str)
以下才通过：
var str string = "ok"
rval := reflect.ValueOf(&str)
rval.Elem().SetString("oooo")
fmt.Printf(str)
修改结构体：
type Student struct {
Id int `json:"id"`
Name string `json:"name"`
}
func (s Student) print() {
fmt.Println(s)
}
func main() {
var stu Student = Student{
Id: 0,
Name: "zhaosi",
}
typeOf := reflect.TypeOf(stu)
valueOf := reflect.ValueOf(stu)
kind := valueOf.Kind()
if kind != reflect.Struct {
fmt.Println("不是结构体")
return
}
nums := valueOf.NumField()
fmt.Println("结构体的字段数为：", nums)
for i := 0; i < nums; i++ {
fmt.Printf("Field %d:值为： %v\n", i, valueOf.Field(i))
//获取到标签
tagval := typeOf.Field(i).Tag.Get("json")
fmt.Printf("json tag:%v\n", tagval)
}
numMethod := valueOf.NumMethod()
fmt.Printf("结构体有：%v 个方法\n", numMethod)
//调用结构体的第一个方法
valueOf.Method(0).Call(nil)
}
3. json （序列化）
结构体:
func main() {
s := Student{Id: 1, Name: "lisi"}
data, err := json.Marshal(&s)
if err != nil {
fmt.Println("序列化错误")
}
fmt.Println(string(data))
}
map :
func testmap() {
var a map[string]interface{}
a=make(map[string]interface{})
a["a"] = "b"
a["b"] = 1
data, err := json.Marshal(a)
if err != nil {
fmt.Println("序列化错误")
}
fmt.Println(string(data))
}
反序列化
func reversejson() {
str := "{\"Id\":1,\"Name\":\"lisi\"}"
var a map[string]interface{}
//a = make(map[string]interface{}) 不需要make
err := json.Unmarshal([]byte(str), &a)
if err != nil {
fmt.Println("反序列化失败")
}
fmt.Println(a)
}
语法入门就差不多了。。。
来源：oschina
链接：https://my.oschina.net/u/4368242/blog/4301574