go语言基础-----01-----go语言特性

go语言基础-----01-----go语言特性 一 go语言特性 1.1 开发环境搭建

实际上就是安装go环境与GoLand IDE工具。
go语言环境：go语言环境下载地址。
GoLand IDE工具：GoLand IDE工具下载地址。不过这个想要破解版需要一个压缩包。

1.2.1 Go语言特性-垃圾回收

a. 内存自动回收，再也不需要开发人员管理内存。b. 开发人员专注业务实现，降低了心智负担。c. 只需要new分配内存，不需要释放。d. gc 垃圾回收 4ms。 1.2.2 Go语言特性-天然并发

a. 从语言层面支持并发，非常简单。b. goroute，轻量级线程，创建成千上万个goroute成为可能。c. 基于CSP（Communicating Sequential Process）模型实现。
测试代码：

// goroute.go
// 1. 一个文件属于一个包，这样表明这个文件属于main这个包，一个包可以有多个文件。
package main

// 2. 导入其它的程序库。若没有使用到该包，go会报错，语法严谨。
import (
	"fmt"
)

// 3. 该包的函数
func test_goroute(a int) {
	fmt.Println(a)
}

// main.go
// 4. 注意需要在main函数的上一层的上一层目录执行即E:go_studygo_code1-srcsrc1：go run .1-1-goroute
// 否则会失败
package main

import (
	"time"
)

func main() {

	// 5. 开启一百个协程。go关键字代表开启协程。
	// go中的协程是：一个线程中开辟，当开辟多个协程时，各自互不干扰，均是异步执行。所以打印可以看到顺序是无序的。
	for i := 0; i < 100; i++ {
		go test_goroute(i)
	}

	// 睡眠1秒
	time.Sleep(time.Second)
}

1.2.3 Go语言特性-channel

a. 管道，类似unix/linux中的pipe，先进先出，一端是读那么另一端就是写，channel是协程安全的，内部会有锁。 与之前的C语言协程对比，一个线程可以运行多个协程，但是不存在竞态关系，1:n的关系，多个协程访问全局变量是安全的，可以认为是一个线程轮询多个线程。而go的线程与协程之间是m:n关系，存在竞态关系。b. 多个goroute之间通过channel进行通信。c. 支持任何类型。

代码测试：

package main

import "fmt"

func test_pipe() {
	pipe := make(chan int, 3)
	pipe <- 1
	pipe <- 2
	pipe <- 3
	var t1 int
	t1 = <-pipe
	fmt.Println("t1: ", t1)

}

func sum(s []int, c chan int) {
	//test_pipe()
	sum := 0
	for _, v := range s {
		sum += v
	}
	fmt.Println("sum:", sum)
	c <- sum // send sum to c
}

func main() {
	// 1. 定义切片s
	s := []int{7, 2, 8, -9, 4, 0}
	// 2. 创建通道c
	c := make(chan int)
	// 3. 将切片的前半部分元素及通道传入协程，协程进行累积和，然后push到通道。
	go sum(s[:len(s)/2], c) // 7+2+8 = 17, -9 + 4+0 = -5
	// 4. 同理，将切片的后半部分元素及通道传入协程，协程进行累积和，然后push到通道。
	go sum(s[len(s)/2:], c)

	// 5. 此时通道应该有两个协程统计后的值。下面进行获取，按照通道的先进先出规则。
	// x, y := <-c, <-c // receive from c
	x := <-c
	y := <-c
	fmt.Println(x, y, x+y)
}

结果：

1.2.4 Go语言特性-多返回值

go的一个函数返回多个值，类似lua。

测试代码：
我的目录结构是这样的，使用到四个go文件。add.go、calc.go、sub.go、main.go。

// add.go
package calc


func Add(a int, b int) int {
	return a + b
}

// calc.go
package calc

func Calc(a int, b int)(int,int) {
    sum := a + b
    avg := (a+b)/2
    return sum, avg
}

// sub.go
package calc

func Sub(a int, b int) int {
	return a - b
}

// main.go
package main

// 因为我在GOPATH设置了E:go_studygo_code1-src为环境变量，而go会自动查找该路径下的src目录，
// 所以下面import calc包时，其路径为："1/1-3-package/calc"。
// 不过注意有时候添加完环境变量后，并不能马上生效，可能需要等一下。
import (
	"1/1-3-package/calc"
	"fmt"
)

func main() {
	sum := calc.Add(100, 300)
	sub := calc.Sub(100, 300)

	fmt.Println("sum=", sum)
	fmt.Println("sub=", sub)

	sum, avg := calc.Calc(100, 300)
	fmt.Println("sum=", sum)
	fmt.Println("avg=", avg)
}

结果：

1.3 第一个golang程序

就是打印hello woeld，这里就不显示了。

1.4.1包的概念

和python一样，把相同功能的代码放到一个目录，称之为包。包可以被其他包引用。main包是用来生成可执行文件，每个程序只有一个main包。包的主要用途是提高代码的可复用性。

1.4.2 包的实战

即如何引用自己的包，具体看回上面1.2.4 Go语言特性-多返回值的例子即可。

二 总结

1）本节主要是先大概了解一下go如何安装环境和相关的语法，如何编译运行，和相关概念等等。