fmt.Println("hello wordld")	// go中句末无需手动添加分号

// 声明初始值时数据类型可以省略，会自动推导 -> var a = 1
var a int = 1

// 未声明初始值时数据类型不可以省略，因为无法根据初始值来推导数据类型
var a		// ×
var a int	// ✔

a := 1	// 同样，数据类型会自动推导

// 通过var在同行声明多个变量的方式限定了所有变量的数据类型必须一致
var a, b int
var a, b = 1, 2

// 该种方式内部的数据类型同样可以省略，且必须有初始值
var (
	a int = 1
	b string = "2"
)

a, b := 5, "6"

// test为一个返回了两个结果的函数
func test(a int, b int) (int, int) {
	return a + b, a - b
}

func main() {
    // 此处，test函数返回的第二个结果是我们所不需要的，无需为其分配内存，因此可以使用匿名变量
	a, _ := test()
	_, b := test() // 匿名变量不存在重复声名
}

private static final int NUM = 235;

// 单常量定义
const k = 0

// 多常量定义，后续相同的可以省略
const (
	x = 0 // 0
	y = 1 // 1
	z     // 1
)

const k0 = iota		// 0
const (
	k1 = iota		// 0 —— 在const关键字出现时将被重置为0
	k2        		// 1 —— 每新增一行常量声明，iota自增
	k3        		// 2
)
const (
	k4 = iota 		// 0
	k5 = 1			// 1
	k6 = iota 		// 2
)
const (
	l1, l2 = iota, iota + 1 // 0 1
	l3, l4                  // 1 2
	l5, l6                  // 2 3
)

var a0 int8
var a1 int16
var a2 int
fmt.Println(unsafe.Sizeof( /*int8(0)*/ a0))  // 1
fmt.Println(unsafe.Sizeof( /*int16(0)*/ a1)) // 2
fmt.Println(unsafe.Sizeof( /*int(0)*/ a2))   // 8

fmt.Printf("10进制 - %d\n", 17)	// 17
fmt.Printf("0进制 - %b\n", 17)	// 10001
fmt.Printf("8进制 - %o\n", 17)	// 21
fmt.Printf("16进制 - %x\n", 17)	// 11

var pi = 3.1415926
// b = 3.1415926 -- 3.141593，保留两位小数后3.14
fmt.Printf("b = %v -- %f，保留两位小数后%.2f", b, b, b)	

var f1 float64 = 8.2
var f2 float64 = 3.8
fmt.Printf("8.2 - 3.8 = %v\n", f1-f2) // 4.3999999999999995

type stringStruct struct {
	str unsafe.Pointer	// 指向长度为len的byte数组
	len int
}

var c = `line1
			line2`
fmt.Println(c)

// 打印结果：
// line1
// 			 	line2

e := "你好"
fmt.Println(len(e)) // 6

str := "你好，golang"
fmt.Println(str)				// 你好，golang
runeStr := []rune(str)			// [20320 22909 65292 103 111 108 97 110 103]
fmt.Println(runeStr)
runeStr[0] = '您'
fmt.Println(string(runeStr))	// 您好，golang

str := "你好，golang"
//	228-ä 189-½ 160-  229-å 165-¥ 189-½ 239-ï 188-¼ 140-Œ 103-g 111-o 108-l 97-a 110-n 103-g
for i := 0; i < len(str); i++ {
	fmt.Printf("%v-%c\t", str[i], str[i])
}

// 	20320-你	22909-好	65292-，	103-g	111-o	108-l	97-a	110-n	103-g
for _, v := range str { // 若需要使用下标 => for i, v := range str
	fmt.Printf("%v-%c\t",  v, v)
}

var a0 int8
var a1 int16
// fmt.Println(a0 + a1)		// × invalid operation: a0 + a1 (mismatched types int8 and int16)
fmt.Println(int16(a0) + a1) // ✔

var arr1 [3]int
var arr2 = [3]int{1, 2, 3}
arr3 := [3]int{1, 2, 3}

var arr4 = [...]int{1, 2, 3}
arr5 := [...]int{1, 2, 3}

arr6 := [...]int{0:1, 2:3}

// 通过索引
for i := range arr {
	fmt.Printf(arr[i] + " ")
}

// foreach
for _, s := range arr {
	fmt.Printf(s + " ")
}

type slice struct {
	array unsafe.Pointer	// 数组指针
	len   int				// 长度
	cap   int				// 容量
}

sliceObj := []int{0, 1, 2, 3, 4, 5}

var sliceObj = sli[1:2]
sliceObj := arr[:]

sliceObj := make([]int, 2, 3)

slices := []int{0, 1, 2, 3, 4, 5}
slice1 := slices[:]		// [0 1 2 3 4 5]	len = 6，cap = 6
slice2 := slices[1:]	// [1 2 3 4 5]		len = 5，cap = 5
slice3 := slices[1:3]	// [1 2]			len = 2，cap = 5

func append(slice []Type, elems ...Type) []Type

sliceA := []int{0, 1}
// 添加元素
sliceA = append(sliceA, 2, 3)		// 0 1 2 3
// 合并切片
sliceB := []int{4, 5}
sliceA = append(sliceA, sliceB...)	// 0 1 2 3 4 5

sliceA = append(sliceA[:1], sliceA[2:]...)	// 0 2 3 4 5

func copy(dst, src []Type) int

sliceC := make([]int, 4, 5)
copy(sliceC, sliceA)	// sliceC = [0 2 3 4]

func Ints(a []int)
func Float64s(a []float64)
func Strings(a []string)

sort.Sort(sort.IntSlice(array)) // 等同于sort.Ints(array)

// 部分源码
type IntSlice []int

func (this IntSlice) Sort() { Sort(this) }

func Sort(data Interface) {
	n := data.Len()
	quickSort(data, 0, n, maxDepth(n))
}

sort.Sort(sort.Reverse(sort.IntSlice(array)))

func Slice(slice interface{}, less func(i, j int) bool)

sort.Slice(array, func(i, j int) bool {
	return array[i] < array[j]
})

public static <T> void sort(T[] a, Comparator<? super T> c)
public static <T> void sort(List<T> list, Comparator<? super T> c)

// 数组
arr1 := [...]int{1, 2, 3}
arr2 := arr1
arr1[0] = 4
fmt.Println("arr1 =", arr1)	// 4 2 3
fmt.Println("arr2 =", arr2)	// 1 2 3

// 切片
slice01 := []int{1, 2, 3}
slice02 := slice01
slice2[0] = 0
fmt.Println("slice01 =", slice01)	// 1 2 3
fmt.Println("slice02 =", slice02)	// 1 2 3

mapA := make(map[int]int)
mapA[0] = 1
mapA[1] = 2
mapA[2] = 3

mapB := map[int]int{
		1: 1, 2: 2, 3: 3,	// 最后的“,”必须要添加，或者这样同行声明 mapB := map[int]int{1: 1, 2: 2, 3: 3}
}

// 定义值为slice的map
mapC := make(map[int][]int)
mapC[0] = []int{1, 2, 3}

val, ok := mapA[0]

delete(mapA, 3)

// 只遍历key，Java中的
for k := range mapA {
	// todo
}

// 同时遍历kv
for k, v := range mapA {
	// todo
}

for (Integer integer : map.keySet()) {
	// todo
}

for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
	int k = entry.getKey();
	int v = entry.getValue();
	// todo
}

func 函数名(入参) (返回结果) {
	// TODO
}

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

func getSum(a ...int) int {
	sum := 0
	for _, i := range a {
		sum += i
	}
	return sum
}

func getSub(a /* int */, b int) int {
	return a - b
}

func getSumAndSub(a, b int) (int, int) {
	return a + b, a - b
}

func getMultiAndDiv(a int, b int) (multi, div int) {
	multi = a * b
	div = a / b
	return multi, div
}

type calccalculate func(int, int) int

func calculate(a, b int, f calc /* 此处 calculate 等同于 func(int, int) int */) int {
	return f(a, b)
}

func main() {
    // 函数作为参数
	fmt.Println(calculate(1, 1, getSub))
    // 匿名函数作为参数
	fmt.Println(calculate(1, 1, func(a int, b int) int {
		return a + b - a*b/a
	}))
	// 函数作为回参
    fmt.Println(calculate(1, 1, funcChoose("/")))
}

func funcChoose(s string) calc {
	switch s {
	case "+":
		return getTwoSum
	case "-":
		return getSub
	case "*": // 匿名函数作为返回结果
		return func(a int, b int) int {
			return a * b
		}
	case "/": // 匿名函数作为返回结果
		return func(a int, b int) int {
			return a / b
		}
	default:
		return nil
	}
}

func init() {
	fmt.Println("ex11：init")
}

func (实例名 实例类型) 方法名()  {
	// 方法体
}

func (p Phone) start() {
	fmt.Println(p.Name, "开机")
}

p := Phone{Name: "OPPO"}
p.start()

func(参数) (返回结果){
	// 函数体
}

// 匿名自执行函数
func(入参) {
    // 函数体
}(参数)

type calc func(int, int) int
type myInt int

func main() {
	var c1 calc = getTwoSum
	fmt.Printf("自定义函数类型的类型：%T\n", c1) // 自定义的 main.calc 类型
	c2 := getTwoSum
	fmt.Printf("自定义函数的类型：%T\n", c2) // 推导得出的是function类型 func(int, int) int
    var c3 myInt
	fmt.Printf("自定义变量类型的类型：%T\n", c3) // main.myInt
}

type myFunc func() int

// 闭包
func add() myFunc {
	i := 1 // 常驻内存，不污染全局
	return func() int {
		i++
		return i
	}
}

func main() {
    fn := add()					// 此处相当于执行了i:=1，并且i常驻内存，fn被赋值为函数 func() int {i++：return i}，每一次调用fn()，都会执行一次i++和return i
	fmt.Println(fn()) // 2
	fmt.Println(fn()) // 3
	fmt.Println(fn()) // 4
}

func main() {
	deferTest()	// 开始 结束 3 2 1
}

func deferTest() {
	fmt.Println("开始")
	defer fmt.Println(1)
	defer fmt.Println(2)
	defer fmt.Println(3)
	fmt.Println("结束")
}

func main() {
	deferTest()	// 1开始  2结束 1开始 2结束 654321
}

func deferTest() {
	fmt.Print("1开始 ")
	defer fmt.Println(1)
	defer fmt.Print(2)
	defer fmt.Print(3)
	fmt.Print(" 2结束 ")
	// 也可以将延迟代码放到匿名函数中
	fmt.Print("1开始 ")
	defer func() {
		defer fmt.Print(4)
		defer fmt.Print(5)
		defer fmt.Print(6)
	}()
	fmt.Print("2结束 ")
}

func main() {
    // - 匿名返回函数
    // 		控制台依次输出：1 0
    fmt.Println(f1()) // ③ 打印输出返回的0
    
    // - 命名返回值函数
    // 		控制台依次输出：1 1
    fmt.Println(f2())
}

// 匿名返回值函数
func f1() int {
	var a int
	defer func() { // ② a自增为1，并输出
		a++
		fmt.Println("defer ", a)
	}()
	return a // ① 返回0
}

// 命名返回值函数
func f2() (a int) {
	defer func() { // ②
		a++
		fmt.Println("defer ", a)
	}()
	return a // ①
}

func main() {
	x := 1
	y := 2
	defer deferCalc("AA", x, deferCalc("A", x, y))
	x = 10
	defer deferCalc("BB", x, deferCalc("B", x, y))
	y = 20
}

func deferCalc(index string, a, b int) int {
	res := a + b
	fmt.Println(index, a, b, res)
	return res
}

A 1 2 3
B 10 2 12

BB 10 12 22
AA 1 3 4

顺序：注册AA -> 执行A -> 注册BB -> 执行B -> 执行BB -> 执行AA
	x := 1
	y := 2
	注册AA	// 注册时需要确定 x，deferCalc("A", x, y)) 的值
		x = 1
		执行A：deferCalc("A", x, y) => A 1 2 3
		deferCalc("A", x, y) = 3
	x = 10
	注册BB	// 注册时需要确定 x，deferCalc("B", x, y)) 的值
		x = 10
		执行B：deferCalc("B", x, y) => B 10 2 12
		deferCalc("B", x, y) = 12
	y = 20
	执行BB：deferCalc("BB", x, deferCalc("B", x, y)) => BB 10 12 22
	执行AA：deferCalc("AA", x, deferCalc("A", x, y)) => AA 1 3 4

func panicTest() {
	/*
		panic: *** panic ***

		goroutine 1 [running]:
		main.panicTest(...)
			golang-learning/src/main/ex7.go:79
		main.main()
			golang-learning/src/main/ex7.go:74 +0x585
	*/
	fmt.Println("before panic")
	panic("*** panic ***")
	fmt.Println("after panic")
}

public static void main(String[] args) throws Exception {
    System.out.println("before throwing");
	throw new Exception("*** throw ***");
	System.out.println("after throwing");	// java: 无法访问的语句
}

func recoverTest(a, b int) {
	defer func() {
		// recover接收异常，只能在defer调用函数中有效
		err := recover()
		if err != nil {
			fmt.Println("error:", err)
		}
	}()
	fmt.Println(a / b)
}

error: runtime error: integer divide by zero

void test(int a, int b) {
	try {
		System.out.println(a / b);
	} catch (Exception e) {
		System.out.println(e);
	}
}

func write2Txt(path string) {
	file, err := os.OpenFile(path, os.O_WRONLY, 666)
    
	defer func() {	// finally
		file.Close()
		myErr := recover()	// catch
		if myErr != nil {
			fmt.Println("error: ", myErr)
		}
	}()

	if err != nil {
		panic("打开文件失败")
	}
    
	_, err = file.WriteString("直接写入字符串\r\n")
	if err != nil {
		panic("写入文件失败")
	}
}

import "time"

time.Now().Year()
time.Now().Month()
time.Now().Day()
time.Now().Hour()
time.Now().Minute()
time.Now().Second()

timeTmp := time.Now()

// 使用format格式化
formatDate1 := timeTmp.Format("2006-01-02 03:04:05") // 使用 03 表示采取12小时制
fmt.Println(formatDate1)                             // 2020-11-04 01:09:32
formatDate2 := timeTmp.Format("2006/01/02 15:04:05") // 使用 15 表示采取24小时制
fmt.Println(formatDate2)                             // 2020/11/04 13:09:32

timeStr := "2021-01-29 18:06:53"
// Local represents the system's local time zone. 代表系统本地时区
timeTmp, _ = time.ParseInLocation("2006-01-02 15:04:05", timeStr, time.Local)

日期字符串[2021-01-29 18:06:53] 转 时间[2021-01-29 18:06:53 +0800 CST]

timeStamp := time.Now().Unix()

// 参数1：秒时间戳，参数2：纳秒时间戳。不需要的设为默认值0即可
t := time.Unix(timeStamp, 0) // 返回结构体Time
timeStamp := time.Now().Unix()
timeStr := t.Format("2006-01-02 15:04:05")

时间戳[1611914813] 转 时间[2021-01-29 18:06:53]

const (
	Nanosecond  Duration = 1
	Microsecond          = 1000 * Nanosecond
	Millisecond          = 1000 * Microsecond
	Second               = 1000 * Millisecond
	Minute               = 60 * Second
	Hour                 = 60 * Minute
)

// 时间加法
func (t Time) Add(d Duration) Time
// 时间减法
func (t Time) Sub(u Time) Duration
// 从t以来经过的时间
// 	类似于time.Now().Sub(t).
func Since(t Time) Duration
// 直到t所需的时间
// 	类似于t.Sub(time.Now()).
func Until(t Time) Duration
// 将时间加上所给年月日并返回
func (t Time) AddDate(years int, months int, days int) Time

timeTmp = timeTmp.Add(time.Hour) // 2021-01-29 18:06:53 + 1h
fmt.Println(timeTmp.Format("2006-01-02 15:04:05"))

// 定义一个定时器，5秒内每隔一秒打印一次当前时间
ticker := time.NewTicker(time.Second) 
n := 5
for t := range ticker.C {
	n--
	fmt.Println(t)
	if n == 0 {
		ticker.Stop() // 终止定时器
		// 若此处不写break退出定时任务语句，会发生死锁：
		// 		fatal error: all goroutines are asleep - deadlock!
		//
		// 		goroutine 1 [chan receive]:
		// 		main.main()
		//		golang-learning/src/main/ex8.go:71 +0x869
		break
	}
}

time.Sleep(time.Second * 3)

type Test struct {
	a int
	b int
}

/* 普通变量 */
var t1 Test = Test{a: 0, b: 0}
// t1 值：{0 0}，类型：main.Test，地址：0xc00000a0c0
fmt.Printf("t1 值：%v，类型：%T，地址：%this\n", t1, t1, &t1)

tt1 := t1
// tt1 值：{0 0}，类型：main.Test，地址：0xc00000a0f0
fmt.Printf("tt1 值：%v，类型：%T，地址：%this\n", tt1, tt1, &tt1)

t1.a = 1         // 修改原t1中a的值
fmt.Println(t1)  // {1 0}
fmt.Println(tt1) // {0 0}	发现此处tt1的a值并没有改变

/* 指针变量 */
var t2 *Test = &Test{a: 0, b: 0}
// t2 值：&{0 0}，类型：*main.Test，地址：0xc000006048，指向地址：0xc00000a140
fmt.Printf("t2 值：%v，类型：%T，地址：%this，指向地址：%this\n", t2, t2, &t2, t2)

tt2 := t2
// tt2 值：&{0 0}，类型：*main.Test，地址：0xc000006050，指向地址：0xc00000a140
fmt.Printf("tt2 值：%v，类型：%T，地址：%this，指向地址：%this\n", tt2, tt2, &tt2, tt2)

t2.a = 1         // 修改原t2中a的值
fmt.Println(t2)  // &{1 0}
fmt.Println(tt2) // &{1 0} 发现此处tt2的a值也发生了改变

/* 数组 */
arr1 := [...]int{1, 2, 3}
// arr1 值：[1 2 3]，类型：[3]int，地址：0xc000012380
fmt.Printf("arr1 值：%v，类型：%T，地址：%this\n", arr1, arr1, &arr1)
arr2 := arr1
// arr1 值：[1 2 3]，类型：[3]int，地址：0xc0000123e0
fmt.Printf("arr1 值：%v，类型：%T，地址：%this\n", arr2, arr2, &arr2)

arr1[0] = 4
fmt.Println("arr1 =", arr1) // [4 2 3]
fmt.Println("arr2 =", arr2) // [1 2 3]


/* 切片 */
slice01 := []int{1, 2, 3}
// slice01 值：[1 2 3]，类型：[]int，地址：0xc0000044a0，指向地址：0xc000012480
fmt.Printf("slice01 值：%v，类型：%T，地址：%this，指向地址：%this\n", slice01, slice01, &slice01, slice01)
slice02 := slice01
// slice02 值：[1 2 3]，类型：[]int，地址：0xc000004520，指向地址：0xc000012480
fmt.Printf("slice02 值：%v，类型：%T，地址：%this，指向地址：%this\n", slice02, slice02, &slice02, slice02)

slice02[0] = 0
fmt.Println("slice01 =", slice01) // [0 2 3]
fmt.Println("slice02 =", slice02) // [0 2 3]

func new(Type) *Type

t := new(Test)
tt := t
// t 值：&{0 0}，类型：*main.Test，地址：0xc000006048，指向的地址：0xc00000a1f0
fmt.Printf("t 值：%v，类型：%T，地址：%this，指向的地址：%this\n", t, t, &t, t)
// tt 值：&{0 0}，类型：*main.Test，地址：0xc000006050，指向的地址：0xc00000a1f0
fmt.Printf("tt 值：%v，类型：%T，地址：%this，指向的地址：%this\n", tt, tt, &tt, tt)

func make(Type, size IntegerType) Type

type StructName struct {
	// 属性
}

type Person struct {
	Name    string
	Age     int
	Addr	Address
}

type Address struct {
	Country string
	City    string
}

var p = new(Person)
var p *Person
var p = &Person{}
p := &Person{}

// 也可以简化初始，属性名称要么都写，要么都省略
var p = &Person{
    /* Name: */ "李四",
    /* age:  */ 18,
    &Address{
        Country: "中国",
    },
}

// 以下两行代码是同一效果
p1.City = "浙江"
p1.Address.City = "浙江"

type Student struct {
	ID     int `json:"id"` // 定义tag做json的kv映射
	Person `json:"person"` // 继承Person类
}

s := &Student{
	ID: 0,
	Person: Person{
		Name:    "小红",
		age:     22,
		Address: &Address{},
	},
}
// 1. 将结构体转换为byte数组
jsonByte, _ := json.Marshal(s)
// 2. byte数组转json字符串
jsonStr := string(jsonByte)	// {"id":0,"person":{"Name":"小红","Country":"","City":""}}

var s *Student
err := json.Unmarshal([]byte(jsonStr), &s)	// &main.Student{ID:0, Person:main.Person{Name:"小红", age:22, Address:(*main.Address)(0xc000004600)}}

func (接收者变量 接收者类型) 方法名(参数列表) (返回参数) {
	// 方法体
}

func (this *Person) SetInfo(name string, age int) {
	this.Name = name
	this.age = age
}

p.SetInfo("哈哈", 22)

type Student struct {
	ID
	Person	// 继承Person类
}

type 接口名 interface {
	// 接口内容
}

type Phone struct {
	Name string
}

type Usber interface {
	charge()
	transport()
	InnerInterface	// 内嵌接口
}

type InnerInterface interface {
	fix()
}

func (p *Phone) transport() {
	fmt.Println(p.Name, "修理")
}

func (p *Phone) charge() {
	fmt.Println(p.Name, "充电")
}

func (p *Phone) fix() {
	fmt.Println(p.Name, "修理")
}

func (c Camera) charge() {
	fmt.Println(c.Name, "充电")
}

func main() {
	var u2 Usber = Camera{Name: "Casio"}
    var u3 Usber = &Camera{Name: "Sony"}
}

func (p *Phone) charge() {
	fmt.Println(p.Name, "充电")
}

func main() {
	var u1 Usber = &Phone{Name: "VIVO"}
}

type Object interface{}

func show(o interface{}) {
	fmt.Printf("值：%v，类型：%T\n", o, o) // 1 int
}

show(1)    // 值：1，类型：int
show("1")  // 值：1，类型：string
show(1.1)  // 值：1.1，类型：float64
show(true) // 值：true，类型：bool

userinfo := make(map[string]interface{})
userinfo["name"] = "张三"
userinfo["age"] = 22
userinfo["hobby"] = []string{"吃饭", "睡觉", "打豆豆"}
userinfo["phone"] = Phone{Name: "oppo"}

x.(T) // 源数据.(目标类型)

var b interface{}
b = "你好，golang"
v, ok := b.(string)
if ok {
	fmt.Println("a是一个string类型的值 ——", v)
} else {
	fmt.Println("a不是一个string类型的值")
}
// a是一个string类型的值 —— 你好，golang

// 	fmt.Println(userinfo["hobby"][1]) 	✖	type interface {} does not support indexing
// 	fmt.Println(userinfo["phone"].Name)	✖	type interface {} is interface with no methods
fmt.Println(userinfo["hobby"].([]string)[0])
fmt.Println(userinfo["phone"].(Phone).Name)

// 协程计数主要由sync中的WaitGroup结构体实现
var wg sync.WaitGroup

func main() {
	wg.Add(1)          // 协程计数器 +1
	go goroutineTest() // 开启一个协程
	wg.Wait()          // 等待协程执行完毕
	fmt.Println("main 退出")
}

func goroutineTest() {
	defer wg.Done()
	// 方法体
}

func (wg *WaitGroup) Done() {
	wg.Add(-1)
}

var wg sync.WaitGroup

func main() {
	wg.Add(2)
	go errFunc()
	go healthyFunc()
	wg.Wait()
}

func errFunc() {
	defer func() {
		if err := recover(); err != nil {
			fmt.Println("【errFunc】执行失败，异常已捕获")
		}
		wg.Done()
	}()
	// 一段有问题的代码
	var myMap map[int]int
	myMap[0] = 0
}

func healthyFunc() {
	defer wg.Done()
	time.Sleep(time.Millisecond * 50)
	fmt.Println("【healthyFunc】执行成功")
}

【errFunc】执行失败，异常已捕获
【healthyFunc】执行成功

make(chan 元素类型, 容量)

channel := make(chan int, 2)
channel <- 1
channel <- 2
// channel <- 3 // 超出容量 -> 管道阻塞	all goroutines are asleep - deadlock!
// 值：0xc00010a000，类型：chan int，容量：3，长度：2
fmt.Printf("值：%v，类型：%T，容量：%v，长度：%v\n", channel, channel, cap(channel), len(channel))
a := <-channel
fmt.Println(a)         // 1
fmt.Println(<-channel) // 2
// fmt.Println(<- channel)	// 超取 -> 管道阻塞	all goroutines are asleep - deadlock!

for i := 0; i < 2; i++ {
	fmt.Println(<-channel)
}

close(channel) // 关闭管道
for v := range channel {
	fmt.Println(v)
}

// 只写管道 —— chan<-
wch := make(chan<- int, 2)
// 只读管道 —— <-chan
rch := make(<-chan int, 2)

var wg sync.WaitGroup

func main() {
	ch := make(chan int, 10)
	wg.Add(2)
	go write(ch)
	go read(ch)
	wg.Wait()
}

func write(ch chan int /* 可使用单向管道（只写）：ch chan<- int */) {
	for i := 0; i < 10; i++ {
		ch <- i
		fmt.Printf("【写入】%v\n", i)
		time.Sleep(time.Millisecond * 50)
	}
    // 写完记得关闭
	close(ch)
	wg.Done()
}

func read(ch chan int /* 可使用单向管道（只读）：ch <-chan int */) {
	for v := range ch {
		fmt.Printf("【读取】%v\n", v)
		time.Sleep(time.Millisecond * 50)
	}
	wg.Done()
}

【写入】0
【读取】0
【写入】1
【读取】1
【写入】2
【读取】2
【写入】3
【读取】3
【写入】4
【读取】4
【写入】5
【读取】5
【写入】6
【读取】6
【写入】7
【读取】7
【写入】8
【读取】8
【写入】9
【读取】9

func main() {
    // 写入数据
	intChan := make(chan int, 5)
	floatChan := make(chan float64, 5)
	for i := 0; i < 5; i++ {
		intChan <- i
		floatChan <- float64(i) + 0.1
	}
    
	// 使用select来获取channel中的数据时无需关闭channel
	for {
		select {
		case v := <-intChan:
			fmt.Printf("【intChan】%v\n", v)
			time.Sleep(time.Millisecond * 50)
		case v := <-floatChan:
			fmt.Printf("【floatChan】%v\n", v)
			time.Sleep(time.Millisecond * 50)
		default:
			fmt.Println("【over】")
			break
		}
	}
}

【floatChan】0.1
【floatChan】1.1
【intChan】0
【intChan】1
【floatChan】2.1
【intChan】2
【intChan】3
【floatChan】3.1
【floatChan】4.1
【intChan】4
【over】

var wg sync.WaitGroup
var mutex sync.Mutex

var count int

func main() {
	for i := 0; i < 20; i++ {
		wg.Add(1)
		go mutexTest()
	}
	go wg.Wait()
}

func mutexTest() {
	mutex.Lock()	// 上锁
	count++
	fmt.Println("count =", count)
	wg.Done()
	mutex.Unlock()	// 解锁
}

cpuNum := runtime.NumCPU()   // 相当于java中的 Runtime.getRuntime().availableProcessors()
fmt.Println("cpu数量", cpuNum) // 12