go语言开发入门
go语言开发入门
每个Go程序包含一个名为main的包以及其main函数，在初始化后，程序从main开始执行，避免引入不使用的包（编译不通过）
基础语法
基本数据类型
bool, byte
int，int8，int16，int32，int64
uint8，uint16，uint32，uint64
float32，float64（没有float类型）
string
变量赋值
var a
a = 12
a := 12
a,b :=12,23
常量赋值
const(
a = iota
b
)
循环只有 for
for i:=0;i<10;i++{
do Something...
}
for{
//相当于while(true){}
}
for _,v:= range list{
//range用法返回list数组或者列表的k,v两个值（k数组索引从0开始，v值）
fmt.Print("%s", v)
}
选择 if 和 switch
a := 1
b := 1
if a+b > 2 {
// 注：if(条件不带括号，且左大括号与if保持同行)
}
- 学习一门语言学会循环
完整demo 大白加大白等于白胖胖.求大,白,胖各是数字多少？
package main
import (
"fmt"
"strconv"
)
/* 大白加大白等于白胖胖.求大,白,胖各是数字多少？ */
func main() {
for d := 1; d < 10; d++ {
for b := 1; b < 10; b++ {
for p := 1; p < 10; p++ {
daBai, _ := strconv.Atoi(strconv.Itoa(d) + strconv.Itoa(b))
// fmt.Println("大白", daBai)
baiPangPang, _ := strconv.Atoi(strconv.Itoa(b) + strconv.Itoa(p) + strconv.Itoa(p))
// fmt.Println("白胖胖", baiPangPang)
if daBai+daBai == baiPangPang {
fmt.Println("-------------------大 白 胖--------------------")
fmt.Printf("大 = %d, 白 = %d, 胖 = %d\n", d, b, p)
fmt.Println("白胖胖: ", baiPangPang)
}
}
}
}
}
数据（array）与切片（slice）
数组声明：ArrayType = "[" ArrayLength "]" ElementType .
var a [32] int
var b [3][5] int
（1）数组是值类型。将一个数组赋值给另一个，会拷贝所有的元素.
（2） 如果你给函数传递一个数组，其将收到一个数组的拷贝，而不是它的指针.
（3）数组的大小是其类型的一部分，类型[10]int和[20]int是不同的。数组长度在声明后，就不可更改.
切片声明：SliceType = "[" "]" ElementType .
var a []int
（1）没有初始化的slice为nil.
（2）切片（slice）对数组进行封装，实际上，切片可以看成大小可以动态变化的数组.
（3）Go中大多数的数组编程都是通过切片完成，而不是简单数组.
一般来说，有两种方式来初始化切片：
//通过数组方式
var myArray [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
var mySlice []int = myArray[:5]
//make方式
make([]T, length, capacity)
Channel
-
Goroutine和channel是Go在“并发”方面两个核心feature。
-
Channel是goroutine之间进行通信的一种方式,go所提倡的"应该以通信作为手段来共享内存"的最直接体现。
Channel声明：
ChannelType = ( "chan" | "chan" "<-" | "<-" "chan" ) ElementType .
var ch chan int
var ch1 chan<- int //ch1只能写
var ch2 <-chan int //ch2只能读
//make初始化
putnamechan := make(chan string, 100) //带缓冲
Goroutine
关键字go，启用Goroutine的唯一途径
//同时向五个人打招呼
func main(){
names := []string{"Eric","Tom","Jack","Jim"}
for _,name:= range names{
go func(){
fmt.Printf("Hello,%s.\n",name)
}()
}
runtime.Gosched()
}
调度模型
-
Go的调度器内部有三个重要的结构：M，P，S
-
M:代表真正的内核OS线程，真正干活的人
-
G:代表一个goroutine，它有自己的栈，instruction pointer和其他信息（正在等待的channel等等），用于调度。
-
P:代表调度的上下文，可以把它看做一个局部的调度器，使go代码在一个线程上跑，它是实现从N:1到N:M映射的关键。
图中看，有2个物理线程M，每一个M都拥有一个context（P），每一个也都有一个正在运行的goroutine。
P的数量可以通过GOMAXPROCS()来设置，它其实也就代表了真正的并发度，即有多少个goroutine可以同时运行。
图中灰色的那些goroutine并没有运行，而是出于ready的就绪态，正在等待被调度。P维护着这个队列（称之为runqueue），
Go语言里，启动一个goroutine很容易：go function 就行，所以每有一个go语句被执行，runqueue队列就在其末尾加入一个
goroutine，在下一个调度点，就从runqueue中取出一个goroutine执行。
其他
- defer语句：调用一个被 defer 的函数时在函数刚要返回之前延迟执行
- panic/recover 异常处理语句
缺陷
- 编译生成的可执行文件尺寸非常大
- 代码可读性差（x,y,z int, a []*struct）
- go的滥用导致不可预见bug（注goroutine的使用应该是保守型的）
有两种思维逻辑会想到使用goroutine
- 业务逻辑需要并发
比如一个服务器，接收请求，阻塞式的方法是一个请求处理完成后，才开始第二个请求的处理。其实在设计的时候我们一定不会这么做，我们会在一开始就已经想到使用并发来处理这个场景，每个请求启动一个goroutine为它服务，这样就达到了并行的效果。这种goroutine直接按照思维的逻辑来使用goroutine
- 性能优化需要并发
一个场景是这样：需要给一批用户发送消息，正常逻辑会使用
for _, user := range users {
sendMessage(user)
}
//但是在考虑到性能问题的时候，我们就不会这样做，如果users的个数很大，比如有1000万个用户？我们就没必要将1000万个用户放在一个routine中运行处理，考虑将1000万用户分成1000份， //每份开一个goroutine，一个goroutine分发1万个用户，这样在效率上会提升很多。这种是性能优化上对goroutine的需求
实例httpmq
http协议实现的消息队列，数据持久化levelDb
//httpmq
mux := http.NewServeMux()
mux.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
} //net/http包起路由做拦截处理（put,get,status,view）
//接收name\data参数
//起四个channel
putnamechan := make(chan string, 100) //入队name管道
putposchan := make(chan string, 100) //入队数据索引管道
getnamechan := make(chan string, 100) //出队name管道
getposchan := make(chan string, 100) //出队数据索引管道
//两个Goroutine做消息管道流入队出队操作
go func(chan string, chan string) {
for {
name := <-putnamechan //
putpos := httpmq_now_putpos(name)
putposchan <- putpos
}
}(putnamechan, putposchan)
go func(chan string, chan string) {
for {
name := <-getnamechan
getpos := httpmq_now_getpos(name)
getposchan <- getpos
}
}(getnamechan, getposchan)
//put入队操作
putnamechan <- name
putpos := <-putposchan
queue_name := name + putpos
if data != "" {
db.Put([]byte(queue_name), []byte(data), nil)
} else if len(buf) > 0 {
db.Put([]byte(queue_name), buf, nil)
}
//get出队操作
getnamechan <- name
getpos := <-getposchan
if getpos == "0" {
w.Write([]byte("HTTPMQ_GET_END"))
} else {
queue_name := name + getpos
v, err := db.Get([]byte(queue_name), nil)
if err == nil {
w.Header().Set("Pos", getpos)
w.Write(v)
} else {
w.Write([]byte("HTTPMQ_GET_ERROR"))
}
}
put操作
name --> putnameChannel --> 生成putPos --> putposChannel --> name+pos生成key持久化data
get操作
name --> getnameChannel --> 生成getPos --> getposChannel --> name+pos生成key getData
