Golang入门 - 并发&反射&序列化

╰半夏微凉° 2023-02-15 03:37 34阅读 0赞

### 文章目录 ###

*  1.并发
 *   *  1.1 创建goroutine
     *  1.2 Go语言的协作程序（goroutine）和普通的协作程序（coroutine）
     *  1.3 goroutine间的通信（channel）
     *   *  1.3.1 使用通道发送数据
         *  1.3.2 使用通道接收数据
         *  1.3.3 通道的多路复用
     *  1.4 同步(lock)
 *  2. 反射
 *  3. json （序列化）

# 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)
    	}
    }

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70]  
以上采用匿名函数的方式，也可采用函数的方式，略

## 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"

![在这里插入图片描述][20200604122355334.png]  
运行时发现所有的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  
![在这里插入图片描述][20200604123310914.png]

func main() { 
    	ch := make(chan int)
    	var chSendOnly chan<- int = ch
    	data := <-chSendOnly
    	fmt.Println(data)
    }

![在这里插入图片描述][20200604123808746.png]

ch := make(chan int)
    	//var chSendOnly chan<- int = ch
    	//data := <-chSendOnly
    	//fmt.Println(data)
    	var chReadOnly <-chan int = ch
    	<-chReadOnly

![在这里插入图片描述][2020060412400198.png]  
带缓冲的通道

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 1]

### 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)
    
    }

![在这里插入图片描述][20200604125729600.png]

## 1.4 同步(lock) ##

通道内部的实现依然使用了各种锁，因此优雅代码的代价是性能。在某些轻量级的场合，原子访问（atomic包）、互斥锁（sync.Mutex）以及等待组（sync.Wait Group）能最大程度满足需求。  
其中介绍等待组：  
等待组内部拥有一个计数器，计数器的值可以通过方法调用实现计数器的增加和减少。当我们添加了N个并发任务进行工作时，就将等待组的计数器值增加N。每个任务完成时，这个值减1。同时，在另外一个goroutine中等待这个等待组的计数器值为0时，表示所有任务已经完成。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][20200604130743970.png]  
原子操作：

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)
    }

![在这里插入图片描述][20200604131625412.png]  
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")

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 3]

# 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)

![在这里插入图片描述][20200604144711259.png]  
以下才通过：

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))
    }

![在这里插入图片描述][20200604134920473.png]  
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))
    }

![在这里插入图片描述][20200604134902479.png]  
反序列化

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)
    }

![在这里插入图片描述][20200604135601773.png]

语法入门就差不多了。。。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200604121602945.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc=,size_16,color_FFFFFF,t_70
[20200604122355334.png]: https://img-blog.csdnimg.cn/20200604122355334.png
[20200604123310914.png]: https://img-blog.csdnimg.cn/20200604123310914.png
[20200604123808746.png]: https://img-blog.csdnimg.cn/20200604123808746.png
[2020060412400198.png]: https://img-blog.csdnimg.cn/2020060412400198.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20200604124016684.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc=,size_16,color_FFFFFF,t_70
[20200604125729600.png]: https://img-blog.csdnimg.cn/20200604125729600.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200604130724798.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc=,size_16,color_FFFFFF,t_70
[20200604130743970.png]: https://img-blog.csdnimg.cn/20200604130743970.png
[20200604131625412.png]: https://img-blog.csdnimg.cn/20200604131625412.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200604131830818.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpdHRsZXdoaXRldmc=,size_16,color_FFFFFF,t_70
[20200604144711259.png]: https://img-blog.csdnimg.cn/20200604144711259.png
[20200604134920473.png]: https://img-blog.csdnimg.cn/20200604134920473.png
[20200604134902479.png]: https://img-blog.csdnimg.cn/20200604134902479.png
[20200604135601773.png]: https://img-blog.csdnimg.cn/20200604135601773.png