golang学习笔记

// 八进制转换十进制
假设：八进制是16
1 6
= 1*8^1   6*8^0
= 8     +  6
= 14
// 十进制转换八进制
14/8    余数
1       6
0       1
        倒着读 = 16  所以14转八进制等于 16
        同理二进制转十进制 和 十进制转二进制是一个道理 

// 一个字节表示8位 首位0表示正数 1表示负数
// 二进制数  => 01111111
// 转换位十进制 => 127 所以 最大是127
// -------- 最小表数范围是多少？
// 首位是1后面表示符号位 就是 二进制 => 10000000
// 减1 => 01111111
// 取反 => 10000000 =>得到一个正数 2^7 = 128
// 加符号 => -128
// 最终表示范围 ===> -128 ~ 127

package main

import "fmt"

func main() {
	// 定义一个整数类型
	// var num1 int8 = 23
	var exceedNum int8 = 128
	fmt.Println(exceedNum)
}
//error: ./playground.go:8:23: cannot use 128 (untyped int constant) as int8 value in variable declaration (overflows)

// 查看变量占用的字节数
package main

import (
	"fmt"
	"unsafe"
)

func main() {
	num := 23
	fmt.Println(unsafe.Sizeof(num))  // 8
}

package main

import (
	"fmt"
)

func main() {
	// 定义浮点类型的数据： 浮点数可以用十进制形式表示，也可以用科学计数法表示，  e/E 都可以
	var num1 float32 = 3.14
	fmt.Println(num1) // 3.14
	var num2 float32 = -3.14
	fmt.Println(num2) // -3.14
	var num3 float32 = 314e-2
	fmt.Println(num3) // 3.14
	var num4 float32 = 314e2
	fmt.Println(num4) // 31400
	var num5 float32 = 314e+2
	fmt.Println(num5) // 31400
	var num6 float64 = 314e+2
	fmt.Println(num6) // 31400

  var num7 float32 = 256.000000917
	fmt.Println(num7) // 256
	var num8 float64 = 256.000000917
	fmt.Println(num8) // 256.000000917

  // golang中默认的浮点类型微：float64
	var num9 = 3.1415926
	fmt.Printf("num9的数据类型是%T", num9) // num9的数据类型是float64%
}

package main

import (
	"fmt"
)

func main() {
	// % 取模 等价公式: a % b = a - a / b * b
	fmt.Println(10 % 3) // 10%3 = 10 - 10/3*3 = 10 - 3*3 = 1
	fmt.Println(-10 % 3) // -1
	fmt.Println(10 % -3) // 1
	fmt.Println(-10 % -3) // -1
	fmt.Println(15 % 4) // 15-15/4*4 = 15-12*4 = 3
	fmt.Println(19 % 3) // 19-19/3*3 = 19-6*3 = 1

  // ++ -- 
  var a int = 8
	a++
	fmt.Println(a) // 9
	a-- 
	fmt.Println(a) // 8
	// go 语言中 ++ 和 -- 只能独立使用 不能参与到运算中去
	// go 语言中 ++ 和 -- 只能写在变量的后面 不能写在变量的前面 --a ++a 是错误的 
}

func main() {
  // &
	var age int = 18
	fmt.Println("age对应的存储空间的地址为：", &age) // age对应的存储空间的地址为： 0x14000014090
   
  // *
	var ptr *int = &age
	fmt.Println(ptr) // 0x14000014090
	fmt.Println("ptr这个指针指向的具体数值为：", *ptr)  // ptr这个指针指向的具体数值为： 18
}

func main() {
  
  // if
	count := 30
	if count < 40 {
		fmt.Println("count为true") // count为true
	}
	if num := 40; num < 50 {
		fmt.Println("num为true") // num为true
	}

  // if else
  var age = 40
	if age < 30 {
		fmt.Println("age不满30啊")
	} else {
		fmt.Println("age已满30啊") // age已满30啊
	}

  // switch
  // ps: case后面不需要break 
  // ps: case 表达式可以跟多个值
  var score int = 87
	switch score / 10 {
	case 10:
		fmt.Println("a")
  case 11, 12, 13:
		fmt.Println("11,12,13")
	default:
		fmt.Println("d") // d
	}

   // for
  sum := 0
	for i := 1; i <= 5; i++ {
		sum += i
	}
	fmt.Println(sum) // 15
}

# 1 函数首字母大写 可以被本包和其他包调用
# 2 首字母小写 只能被本包调用
# 3 如果没有返回值 返回值类型什么不写都可以
# 4 在go语言中 函数不支持重载 // 重载就是当函数名相同 形参不同是可以正常运行的 如果不能就是不支持重载
package main
import "fmt"

// 自定义函数
func cal(num1 int, num2 int) int {
	num := 0
	num += num1
	num += num2
	return num
}

// 返回多个值
func multiple(num1 int, num2 int) (int, int) {
	num := 0
	num += num1
	num += num2
	result := num1 - num2
	return num, result
}
// 可变参数 多个参数
func test(args ...int) {
  length := len(args)
	fmt.Println(args, args[1],length) // [1 2] 1 2
}

func main() {
	sum := cal(20, 7)
	fmt.Println(sum) // 27
   
  a1, a2 := multiple(20, 7) 
  fmt.Println(a1, a2) // 27 13
  // 如果有返回值不想接受 可以用_进行忽略 
  a3, _ := multiple(20, 7)
	fmt.Println(a3) // 27

  test(1,2)
}

package main

import "fmt"

func test1(num1 *int) {
	*num1 = 30 // 取到num引用地址对应的值 进行赋值操作
	fmt.Println(num1, *num1) // 0x1400011a018 30
}

func main() {

	num := 10
	test1(&num) // 传进去的是num的引用地址
	fmt.Println(num) // 30
}

package main

import "fmt"

func test(num int) {
	fmt.Println(num)
}

func test02(num1 int, num2 float32, testfunc func(int)) {
	fmt.Println(num1, num2) // 1 3.14
	testfunc(num1) // 1
}

func main() {
	// golang中 函数也是一种数据类型 可以赋值给变量
	t := test
	fmt.Printf("t对应的类型：%T,test1对应的类型：%T \n", t, test) // t对应的类型：func(int),test1对应的类型：func(int)
	t(10) // 10

	test02(1, 3.14, test)
}

package main

import "fmt"

func test(num1 int) {
	fmt.Println(num1)
}

// 别名 用法1
type myFunc func(int)

func test1(num1 int, testfunc1 myFunc) {
	testfunc1(num1) // 1
}

// 别名用法2 类型前定义具体的名称 返回的时候可以不写
func test2(num1 int, num2 int) (sum1 int, sub1 int) {
	sum1 = num1 + num2
	sub1 = num1 - num2
	return
}

func main() {
	type myInt int
	var a1 myInt = 1
	var a2 int = 2
  // error: 不能将int类型的值给自定义类型的值
	a2 = a1 // a2 = int(a1) // 可以通过int类型将自定义类型转换为int类型 就不会报错
	fmt.Println(a2, a2) // ./playground.go:74:7: cannot use a1 (variable of type myInt) as int value in assignment
  
  fmt.Println("-------------")
	test1(1, test)
  
  t1, t2 := test2(1, 2)
	fmt.Println(t1, t2) // 3 -1
}

package main

import "fmt"

func test() {

	defer func() {
		err := recover()
		if err != nil {
			fmt.Println("err = ", err) // err =  runtime error: integer divide by zero
		}
	}()
	num := 10
	num2 := 0
	result := num / num2
	fmt.Println("result = ", result)
}

func main() {
	test() // 可以捕获错误 不会影响下面代码的执行
	fmt.Println("main()下面的代码...") // main()下面的代码...
}

package main

import (
	"errors"
	"fmt"
)

func test() (err error) {

	num := 10
	num2 := 0
	if num2 == 0 {
		return errors.New("除数不能为0")
	} else {
		result := num / num2
		fmt.Println("result = ", result)
		return nil
	}
}

func main() {
	err := test()
	if err != nil {
		fmt.Println("err = ", err) // 除数不能为0
	}
	fmt.Println("main()下面的代码...") // main()下面的代码...
}

package main

import (
	"errors"
	"fmt"
)

func test() (err error) {

	num := 10
	num2 := 0
	if num2 == 0 {
		return errors.New("除数不能为0")
	} else {
		result := num / num2
		fmt.Println("result = ", result)
		return nil
	}
}

func main() {
	err := test()
	if err != nil {
		fmt.Println("err = ", err) // 除数不能为0
		panic(err) // 除数不能为0
    //* return 也行啊
	}
  // ----下面代码不会执行------
	fmt.Println("main()下面的代码...")
}

package main

import (
	"fmt"
)

func main() {
	var scores [5]int
	for i := 0; i < len(scores); i++ {
		fmt.Printf("请录入第%d学生的成绩：", i+1)
		fmt.Scanln(&scores[i]) //
	}

	sum := 0
	for i := 0; i < len(scores); i++ {
		sum += scores[i]
	}

	avg := sum / len(scores)
	fmt.Printf("总成绩为：%v,总成绩平均分为%v \n", sum, avg)

	for i := 0; i < len(scores); i++ {
		fmt.Printf("第%d学生的成绩为：%d\n", i+1, scores[i])
	}

	fmt.Println("--------------第二种遍历方式--------------------------")
	for i, v := range scores {
		fmt.Printf("第%d学生的成绩为：%d\n", i+1, v)
	}
}

package main

import (
	"fmt"
)

func main() {
	// 第一种：
	var arr1 [3]int = [3]int{1, 2, 3}
	fmt.Println(arr1)
	// 第二种：
	var arr2 = [3]int{4, 5, 6}
	fmt.Println(arr2)
	// 第三种：
	var arr3 = [...]int{7, 8, 9}
	fmt.Println(arr3)
	// 第四种：
	var arr4 = [...]int{1: 10, 2: 20}
	fmt.Println(arr4)
}

package main

import (
	"fmt"
)

func main() {
	// 定义数组：
	intarr := [...]int{3, 5, 6, 7}

	// 从0开始 [0,3) 3,5,6
	slice := intarr[0:3]

	fmt.Println("intarr=", intarr)        // intarr= [3 5 6 7]
	fmt.Println("slice=", slice)          // slice= [3 5 6]
	fmt.Println("slice len=", len(slice)) // slice len= 3
	// 容量
	fmt.Println("slice cap=", cap(slice)) // slice cap= 4

	fmt.Printf("数组中下标为0位置的地址：%p\n", &intarr[0])   // 数组中下标为0位置的地址：0x1400012e000
	fmt.Printf("slice切片的下标为0的地址：%p\n", &slice[0]) //  slice切片的下标为0的地址：0x1400012e000

	slice[0] = 99
	fmt.Println("intarr=", intarr) // intarr= [99 5 6 7]
	fmt.Println("slice=", slice)   //  slice= [99 5 6]
}

package main

import (
	"fmt"
)

func main() {
  // make底层创建一个数组 对外不可见 不能直接操作 通过slice间接去访问各个元素
	// 定义切片：make函数的三个参数：1切片类型 2切片长度 3切片容量
	slice := make([]int, 5, 10)
	fmt.Println(slice)                // [0 0 0 0 0]
	fmt.Println("切片的长度：", len(slice)) // 切片的长度： 5
	fmt.Println("切片的容量：", cap(slice)) // 切片的容量： 10

	slice[0] = 66
	slice[1] = 99
	fmt.Println(slice) // [66 99 0 0 0]
}

package main

import (
	"fmt"
)

func main() {
	// 定义切片：make函数的三个参数：1切片类型 2切片长度 3切片容量
	slice := make([]int, 5, 10)
	slice[0] = 66
	slice[1] = 99
	slice[2] = 43
	slice[3] = 11
	slice[4] = 22

	for i := 0; i < len(slice); i++ {
		fmt.Printf("slice[%d]=%v \t", i, slice[i]) // slice[0]=66     slice[1]=99     slice[2]=43     slice[3]=11     slice[4]=22
	}
	fmt.Println("\n-------------------------")

	for k, v := range slice {
		fmt.Printf("slice[%d]=%v\t", k, v) // slice[0]=66     slice[1]=99     slice[2]=43     slice[3]=11     slice[4]=22
	}
}

package main

import (
	"fmt"
)

func main() {

	intarr := []int{3, 4, 5, 6}

	slice := intarr[0:2]
	fmt.Println(slice) // [3 4]

	slice2 := slice[0:1]
	fmt.Println(slice2) // [3]

	slice3 := append(slice2, 99, 100) // append 相当于创建了一个新的数组 把原来的数组复制过来

	fmt.Println(slice3) // [3 99 100]
	// 底层原理：
	// 1 创建新的数组 将老数组中的值复制过来 在新数组中追加新的值
	// 2 slice3 指向的是一个新的数组

	// 给slic2追加值:
	slice2 = append(slice2, 88)
	fmt.Println(slice2) // [3 88]

	fmt.Println("\n-------------------")

	// todo: 拷贝
	a := []int{1, 2, 3, 4, 5}
	b := make([]int, 10)
	copy(b, a)
	fmt.Println(b) // [1 2 3 4 5 0 0 0 0 0]
}

package main

import "fmt"

func main() {
	// 1 map使用一定要mack 才会分配空间
	// 2 map存储是无序的 key不可以重复 重复后者会替换前者 value可以重复
	//
	a := make(map[int]string, 10) // 10是容量 可以省略
	a[20230201] = "zhangsan"
	a[20230611] = "kingcwt"
	fmt.Println(a, "\n", a[20230611])

	// 另一种定义方式
	c := map[int]string{
		20200101: "wangwu",
		20200102: "zhaoliu",
	}

	c[20230611] = "kingcwt"
	fmt.Println(c)
}

package main

import "fmt"

func main() {

	b := map[int]string{
		20230101: "元旦",
		20230211: "春节",
	}

	// add:
	b[20230405] = "清明节"
	// change:
	b[20230211] = "春节2"
	// delete:
	delete(b, 20230405)
	fmt.Println(b)
	// find:
	v, ok := b[20230211] // v是值 ok是boolean 找到返回true 否则false
	fmt.Println(v, ok)

	fmt.Println("-----------------------------------")

	// 遍历：

	a := map[int]string{
		20220103: "zhangsan",
		20220104: "lisi",
		20220105: "wangwu",
	}

	for k, v := range a {
		fmt.Printf("key:%d, value:%s\n", k, v)
		// key:20220105, value:wangwu
		// key:20220103, value:zhangsan
		// key:20220104, value:lisi
	}

	fmt.Println("-----------------------------------")

	d := make(map[string]map[int]string, 3)

	d["北京"] = make(map[int]string, 3)
	d["北京"][20220103] = "zhangsan"
	d["北京"][20220104] = "lisi"
	d["北京"][20220105] = "wangwu"

	d["上海"] = make(map[int]string, 3)
	d["上海"][20220103] = "zhangsan"
	d["上海"][20220104] = "lisi"
	d["上海"][20220105] = "wangwu"

	d["广州"] = make(map[int]string, 3)
	d["广州"][20220103] = "zhangsan"
	d["广州"][20220104] = "lisi"
	d["广州"][20220105] = "wangwu"

	for k, v := range d {
		fmt.Println(k)
		for k1, v1 := range v {
			fmt.Printf("学号：%d,姓名：%s\t", k1, v1)
		}
		fmt.Println()
	}
	// 北京
	// 学号：20220103,姓名：zhangsan   学号：20220104,姓名：lisi       学号：20220105,姓名：wangwu
	// 上海
	// 学号：20220103,姓名：zhangsan   学号：20220104,姓名：lisi       学号：20220105,姓名：wangwu
	// 广州
	// 学号：20220103,姓名：zhangsan   学号：20220104,姓名：lisi       学号：20220105,姓名：wangwu
}

package main

import "fmt"

type Class struct {
	Name  string
	Age   int
	Hobby string
}

func main() {
	// 1. 结构体创建方式1
	var n1 Class
	fmt.Println(n1) // {0}
	n1.Name = "张三"
	n1.Age = 18
	n1.Hobby = "打篮球"
	fmt.Println(n1) // {张三 18 打篮球}

	// 2. 结构体创建方式2
	var t Class = Class{"李四", 31, "打游戏"}
	fmt.Println(t)

	// 3. 结构体创建方式3
	var c1 *Class = new(Class)
	fmt.Println(c1) // &{0}
	(*c1).Name = "王五"
	(*c1).Age = 20
	(*c1).Hobby = "打乒乓球"
	fmt.Println(*c1) // {王五 20 打乒乓球}
	// * 为了符合程序猿的编程习惯，go语言中提供了简化写法
	c1.Name = "汪苏泷"
	c1.Age = 30
	c1.Hobby = "唱歌"
	fmt.Println(*c1)

	// 4. 结构体创建方式4
	var c2 *Class = &Class{"王传君", 30, "唱歌"}
	fmt.Println(c2) // &{王传君 30 唱歌}
	c2.Hobby = "打豆豆"
	fmt.Println(*c2) // {王传君 30 打豆豆}
}

package main

import "fmt"

type Student struct {
	age int
}

type Person struct {
	age int
}

type Stu Student

func main() {
  // 强制转换
	var s Student = Student{10}
	var p Person = Person{20}
	fmt.Println(s) // {10}
	s = Student(p)
	fmt.Println(s) // {20}
	fmt.Println(p) // {20}
	fmt.Println("\n------------------------")

	// todo: 结构体进行type重新定义后 相当于起别名 Golang认为是两个不同的类型 但是相互间可以强转
	var s1 Stu = Stu{30}
	var s2 Student = Student{40}
	s1 = Stu(s2)
	fmt.Println(s1) // {40}
	fmt.Println(s2) // {40}

}

type A struct {
  Num int
}

func (a A) test(){
  fmt.Println(a.Num)
}

var a A
a.test()
// 个人理解 其实就是js的原型链 A其实就是类 Num就是属性 完事test() 其实就是原型上的一个方法 可以访问A上面的属性

package main

import "fmt"

type Person struct {
	Name string
}

func (p Person) test() {
  p.Name = "王武"
	fmt.Println(p.Name)  // 王武
}

func main() {
	var p Person
	p.Name = "张三"
	p.test()
  fmt.Println(p.Name) // 张三
}

// 方法和指定的类型进行绑定的。 p.test() 

package main

import (
	"fmt"
	"time"
)

func showMsg(msg string) {
	for i := 0; i < 5; i++ {
		fmt.Printf("msg: %v\n", msg)
		time.Sleep(time.Millisecond * 100) // 睡 100ms
	}
}
func main() {
	showMsg("javascript")
	showMsg("go")
}

// 打印：
msg: javascript
msg: javascript
msg: javascript
msg: javascript
msg: javascript
msg: go
msg: go
msg: go
msg: go
msg: go

package main

import (
	"fmt"
	"time"
)

func showMsg(msg string) {
	for i := 0; i < 5; i++ {
		fmt.Printf("msg: %v\n", msg)
		time.Sleep(time.Millisecond * 100) // 睡 100ms
	}
}
func main() {
	go showMsg("javascript") // 这里开启了一个协程
	showMsg("go")
}

// 打印：
msg: go
msg: javascript
msg: javascript
msg: go
msg: go
msg: javascript
msg: javascript
msg: go
msg: javascript
msg: go

package main

import (
	"fmt"
	"time"
)

func showMsg(msg string) {
	for i := 0; i < 5; i++ {
		fmt.Printf("msg: %v\n", msg)
		time.Sleep(time.Millisecond * 100) // 睡 100ms
	}
}
func main() {
	go showMsg("javascript")
	go showMsg("go")
	fmt.Println("main end") // 因为主函数退出 程序就结束了 所以协程会自动关闭 也就不会打印上面的
}

// 打印：
main end

package main

import (
	"fmt"
	"time"
)

func showMsg(msg string) {
	for i := 0; i < 5; i++ {
		fmt.Printf("msg: %v\n", msg)
		time.Sleep(time.Millisecond * 100) // 睡 100ms
	}
}
func main() {
	go showMsg("javascript")
	go showMsg("go")
	time.Sleep(time.Millisecond * 2000) // 睡 2s
	fmt.Println("main end")
}

// 打印：
msg: go
msg: javascript
msg: javascript
msg: go
msg: javascript
msg: go
msg: go
msg: javascript
msg: javascript
msg: go
main end

package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"time"
)

func responseSize(url string) {
	fmt.Println("Step1:", url)
	response, err := http.Get(url)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Step2:", url)
	defer response.Body.Close()

	fmt.Println("Step3:", url)
	body, err := ioutil.ReadAll(response.Body)
	if err != nil {
		log.Fatal(err)
	}
	fmt.Println("Step4:", len(body))
}
func main() {
	go responseSize("https://www.qq.com")
	go responseSize("https://www.baidu.com")
	go responseSize("https://www.jd.com")
	time.Sleep(10 * time.Second)

	// 打印：
	Step1: https://www.qq.com
	Step1: https://www.jd.com
	Step1: https://www.baidu.com
	Step2: https://www.jd.com
	Step3: https://www.jd.com
	Step4: 186090
	Step2: https://www.baidu.com
	Step3: https://www.baidu.com
	Step4: 227
	Step2: https://www.qq.com
	Step3: https://www.qq.com
	Step4: 328
}

package main

import (
	"fmt"
	"math/rand"
	"time"
)

var values = make(chan int)

func send() {
	rand.Seed(time.Now().UnixNano())
	value := rand.Intn(10)
	fmt.Printf("Sending value: %v\n", value)
	time.Sleep(time.Second * 5)
	values <- value

}

func main() {
	defer close(values)
	go send()
	fmt.Println("wait...")
	value := <-values
	fmt.Printf("receive: %v\n", value)
	fmt.Println("done")
}

// 打印：
wait...
Sending value: 3
receive: 3
done

package main

import (
	"fmt"
	"sync"
)

var wp sync.WaitGroup

func showMsg(i int) {

	defer wp.Done() // wp.add(-1)的意思
	fmt.Printf("i:%v\n", i)
}

func main() {

	for i := 0; i < 10; i++ {
		go showMsg(i)
		wp.Add(1)
	}
	wp.Wait() // 等待所有的goroutine执行完毕

	fmt.Println("main end")
}

// 打印：
i:9
i:5
i:6
i:7
i:8
i:2
i:3
i:1
i:4
i:0
main end

// package utils
func showGoexit() {
	for i := 0; i < 10; i++ {
		fmt.Printf("i:%v\n", i)
		if i >= 5 {
			runtime.Goexit() // 到5的时候 直接退出
		}
	}
}

func TestGoexit() {
	go showGoexit()
	time.Sleep(time.Second)
}

//-----

package main

import (
	"go3/utils"
)

func main() {
	utils.TestGoexit()
}
// 打印：
i:0
i:1
i:2
i:3
i:4
i:5

func showA() {
	for i := 0; i < 10; i++ {
		fmt.Printf("A:%v\n", i)
		time.Sleep(time.Microsecond * 100)
	}
}
func showB() {
	for i := 0; i < 10; i++ {
		fmt.Printf("B:%v\n", i)
		time.Sleep(time.Microsecond * 100)
	}
}
func TestRuntimeGOMAXPROCS() {
	runtime.GOMAXPROCS(1) // 设置cpu核心数为1
	fmt.Printf("cpu num:%v\n", runtime.NumCPU()) // 打印当前机器的cpu核心数
	go showA()
	go showB()
	time.Sleep(time.Second)
}

package main

import (
	"go3/utils"
)

func main() {
	utils.TestRuntimeGOMAXPROCS()
}

// 打印：
cpu num:12
B:0
A:0
A:1
B:1
B:2
A:2
A:3
B:3
B:4
A:4
A:5
B:5
B:6
A:6
A:7
B:7
B:8
A:8
A:9
B:9

var m int = 100

func add() {
	m += 1
	fmt.Println("add++", m)
}
func sub() {
	m -= 1
	fmt.Println("sub--", m)
}

func TestMutex() {

	for i := 0; i < 100; i++ {
		add()
		sub()
	}
	fmt.Printf("end===:%v\n", m)
}

var m int = 100
var wg sync.WaitGroup

func add() {
	defer wg.Done()
	m += 1
	fmt.Println("add++", m)
}
func sub() {
	defer wg.Done()
	m -= 1
	fmt.Println("sub--", m)
}

func TestMutex() {

	for i := 0; i < 100; i++ {
		wg.Add(1)
		go add()
		wg.Add(1)
		go sub()
	}
	wg.Wait()
	fmt.Printf("end===:%v\n", m)
}

var m int = 100
var wg sync.WaitGroup
var lock sync.Mutex

func add() {
	lock.Lock()
	defer wg.Done()
	m += 1
	fmt.Println("add++", m)
	lock.Unlock()
}
func sub() {
	lock.Lock()
	defer wg.Done()
	m -= 1
	fmt.Println("sub--", m)
	lock.Unlock()
}

func TestMutex() {

	for i := 0; i < 100; i++ {
		wg.Add(1)
		go add()
		wg.Add(1)
		go sub()
	}
	wg.Wait()
	fmt.Printf("end===:%v\n", m)
}

var m int = 100
var wg sync.WaitGroup

func add() {
	defer wg.Done()
	m += 1
	fmt.Println("add++", m)
}
func sub() {
	defer wg.Done()
	m -= 1
	fmt.Println("sub--", m)
}

func TestMutex() {

	for i := 0; i < 100; i++ {
		wg.Add(1)
		go add()
		wg.Add(1)
		go sub()
	}
	wg.Wait()
	fmt.Printf("end===:%v\n", m)
}

var m int = 100
var wg sync.WaitGroup
var lock sync.Mutex

func add() {
	lock.Lock()
	defer wg.Done()
	m += 1
	fmt.Println("add++", m)
	lock.Unlock()
}
func sub() {
	lock.Lock()
	defer wg.Done()
	m -= 1
	fmt.Println("sub--", m)
	lock.Unlock()
}

func TestMutex() {

	for i := 0; i < 100; i++ {
		wg.Add(1)
		go add()
		wg.Add(1)
		go sub()
	}
	wg.Wait()
	fmt.Printf("end===:%v\n", m)
}

package service

import "fmt"

var c = make(chan int)

func TestChan() {
	go func() {
		for i := 0; i < 2; i++ {
			c <- i + 1
		}
		close(c) // 如果没有值 则关闭 读取默认值0
	}()
	r := <-c
	fmt.Printf("r:%v\n", r)
	r = <-c
	fmt.Printf("r:%v\n", r)
	r = <-c
	fmt.Printf("r:%v\n", r)
}

//----------main-----
package main

import (
	"go3/service"
)

func main() {
	service.TestChan()
}

// 打印：
r:1
r:2
r:0

package service

import "fmt"

var c = make(chan int)

func TestChan() {
	go func() {
		for i := 0; i < 2; i++ {
			c <- i + 1
		}
		close(c) // 如果没有值 则关闭 读取默认值0
	}()

	for v := range c {
		fmt.Printf("v:%v\n", v)
	}

}

package service

import (
	"fmt"
	"time"
)

var chanInt = make(chan int)
var chanStr = make(chan string)

func TestSelect() {
	go func() {
		chanInt <- 100
		chanStr <- "hello"
		defer close(chanInt)
		defer close(chanStr)
	}()

	for {
		select {
		case r := <-chanInt:
			fmt.Printf("chanInt:%v\n", r)
		case r := <-chanStr:
			fmt.Printf("chanStr:%v\n", r)
		default:
			fmt.Printf("default...\n")
		}
		time.Sleep(time.Second)
	}
}

// ---main
package main

import (
	"go3/service"
)

func main() {
	service.TestSelect()
}

//打印：
default...
chanInt:100
chanStr:hello
chanStr:
chanStr:
chanInt:0
chanInt:0
chanStr:
chanStr:
chanInt:0
chanStr:
chanInt:0
chanInt:0
chanStr:
chanStr:
chanStr:
.........

package service

import (
	"fmt"
	"time"
)

func TestTimer() {
	timer := time.NewTimer(time.Second * 2)
	fmt.Printf("time.now:%v\n", time.Now())
	t1 := <-timer.C //阻塞的,直到时间到了
	fmt.Printf("t1:%v\n", t1)
}

//---main
package main

import (
	"go3/service"
)

func main() {
	service.TestTimer()
}
// 打印：
time.now:2023-06-26 23:11:01.129658 +0800 CST m=+0.000274584
t1:2023-06-26 23:11:03.130747 +0800 CST m=+2.001303126

// 只是单纯的等待 1
package service

import (
	"fmt"
	"time"
)

func TestTimer() {
	fmt.Printf("time.now:%v\n", time.Now())
	timer := time.NewTimer(time.Second * 2)
	<-timer.C
	fmt.Printf("time.now:%v\n", time.Now())
}

// 打印：
time.now:2023-06-26 23:16:18.480631 +0800 CST m=+0.000201834
time.now:2023-06-26 23:16:20.482047 +0800 CST m=+2.001557542

// 只是单纯的等待 2
time.Sleep(time.Second)
// 只是单纯的等待 3
<-time.After(time.Second*2)

timer := time.NewTimer(time.Second)
timer.Stop() // 停止定时器 执行下面代码
timer.Reset(time.Second *1) // 重新赋值为1秒

package service

import (
	"fmt"
	"time"
)

func TestTicker() {
	ticker := time.NewTicker(time.Second)
	for _ = range ticker.C {
		fmt.Println("ticker...")
	}
}

// main
package main

import (
	"go3/service"
)

func main() {
	service.TestTicker()
}

// 打印: 会一直打印
ticker...
ticker...
ticker...
ticker...
ticker...
ticker...
ticker...
ticker...
ticker...
ticker...
ticker...
...

// 停止周期打印
func TestTicker() {
	ticker := time.NewTicker(time.Second)
	counter := 1
	for _ = range ticker.C {
		fmt.Println("ticker...")
		counter++
		if counter >= 6 {
			ticker.Stop()
			break
		}
	}

}

// 打印：
ticker...
ticker...
ticker...
ticker...
ticker...

package service

import (
	"fmt"
	"time"
)

func TestTickerSelect() {

	ticker := time.NewTicker(time.Second)
	chanInt := make(chan int)

	sum := 0
	go func() {
		for v := range chanInt {
			fmt.Println(v)
			sum++
		}
	}()

	for _ = range ticker.C {
		select {
		case chanInt <- 1:
		case chanInt <- 2:
		case chanInt <- 3:
		}
		if sum >= 10 {
			break
		}
	}

}

// main
package main

import (
	"go3/service"
)

func main() {
	service.TestTickerSelect()
}

// 打印:
3
1
2
2
1
1
3
2
2
3

- func AddInt32(addr *int32, delta int32) (new int32)
- func AddInt64(addr *int64, delta int64) (new int64)
- func AddUint32(addr *uint32, delta uint32) (new uint32)
- func AddUint64(addr *uint64, delta unit64) (new uint64)
- func AddUintptr(addr *uintptr, delta uintptr) (new uintptr)

package service

import (
	"fmt"
	"sync/atomic"
)

// todo: 读写
func test_load_store() {
	var i int32 = 100
	atomic.LoadInt32(&i)       // 读取 read
	fmt.Printf("i:%v\n", i)    // 100
	atomic.StoreInt32(&i, 200) // 写入操作
	fmt.Printf("i:%v\n", i)    // 200
}

// todo: cas
func test_cas() {
	// cas
	var i int32 = 100
	b := atomic.CompareAndSwapInt32(&i, 100, 200) // 比较并且修改 如果有别的线程进来修改这个值 哪就返回false
	fmt.Printf("b: %v\n", b)                      // true
	fmt.Printf("i: %v\n", i)                      // 200
}

func TestAtomicOperate() {
   test_cas()
   test_load_store()
}

// 方式1 通过lock的方式 保证输出的结果正确
package service

import (
	"fmt"
	"sync"
	"time"
)

var i = 100

var lock sync.Mutex

func add() {
	lock.Lock()
	i++
	lock.Unlock()
}

func sub() {
	lock.Lock()
	i--
	lock.Unlock()
}
func TestAtomic() {
	for i := 0; i < 100; i++ {
		go add()
		go sub()
	}

	time.Sleep(time.Second * 2)
	fmt.Printf("i:%d\v", i)
}

// 打印：i:100
--------------------------------------------------

// 方式2  --原子操作
package service

import (
	"fmt"
	"sync/atomic"
	"time"
)

var i int32 = 100

// cas compare and swap 比较并且交换
func add() {
	atomic.AddInt32(&i, 1)

}
func sub() {
	atomic.AddInt32(&i, -1)
}

func TestAtomic() {
	for i := 0; i < 100; i++ {
		go add()
		go sub()
	}

	time.Sleep(time.Second * 2)
	fmt.Printf("i:%d\v", i)
}

// 打印 i:100

//--------- main

package main

import (
	"go3/service"
)

func main() {
	service.TestAtomic()
}

package mos

import (
	"fmt"
	"os"
)

// todo: 创建文件
func createFile() {
	f, err := os.Create("a.txt")
	if err != nil {
		fmt.Printf("err: %v\n", err)
	} else {
		fmt.Printf("f.name(): %v\n", f.Name())
	}
}

// todo: 创建目录
func makeDir() {
	err := os.Mkdir("a", os.ModePerm) //Mkdir 创建一个目录 os.ModePerm表示最高权限
	if err != nil {
		fmt.Printf("err: %v\n", err)
	}
	err2 := os.MkdirAll("a/b/c", os.ModePerm) // 创建a目录下的b目录下的c目录 a->b->c
	if err2 != nil {
		fmt.Printf("err2: %v\n", err2)
	}
}

// todo: 删除目录或则文件
func remove() {
	err := os.Remove("a.txt") // 删除a.txt文件
	if err != nil {
		fmt.Printf("err: %v\n", err)
	}

	err2 := os.RemoveAll("a") // 删除a下的所有文件
	if err2 != nil {
		fmt.Printf("err2: %v\n", err2)
	}
}

// todo: 工作目录操作
func wd() {
	dir, _ := os.Getwd()         // 1. 获取工作目录
	fmt.Printf("dir: %v\n", dir) // dir: /Users/cuihongran/Desktop/demo/go3

	err := os.Chdir("d:/") // 2 修改工作目录
	if err != nil {
		fmt.Printf("err: %v\n", err) // chdir d:/: no such file or directory
	}
	dir2, _ := os.Getwd()
	fmt.Printf("dir2: %v\n", dir2) // dir2: /Users/cuihongran/Desktop/demo/go3

	s := os.TempDir()        // 3 获取临时工作目录
	fmt.Printf("s: %v\n", s) // s: /var/folders/qt/qfgjw21x1rl7zwyylqy453mc0000gn/T/

}

// todo: 重命名文件
func renameFile() {
	err := os.Rename("a.txt", "testa.txt")
	if err != nil {
		fmt.Printf("err: %v\n", err)
	}
}

// todo: 读文件
func readFile() {
	b, err := os.ReadFile("testa.txt")
	if err != nil {
		fmt.Printf("err: %v\n", err)
	} else {
		fmt.Printf("b: %v\n", string(b[:]))
	}
}

// todo: 写文件
func writeFile() {
	s := "hello golang"
	os.WriteFile("testa.txt", []byte(s), os.ModePerm)
}

// todo: 写入新内容
func readFile_writeFile() {
	b, err := os.ReadFile("testa.txt")
	if err != nil {
		fmt.Printf("err: %v\n", err)
	} else {
		oldContent := string(b[:])
		newContent := "我是后写入的内容..."
		mergeContent := oldContent + newContent
		os.WriteFile("testa.txt", []byte(mergeContent), os.ModePerm)
	}
}

func MosMain() {
	createFile() //  在当前根目录下创建了a.txt
	makeDir()
	remove()
	wd()
	renameFile()
	readFile()
	writeFile()
	readFile_writeFile()
}

// main 
package main

import "go3/mos"

func main() {
	mos.MosMain()
}

package mos

import (
	"fmt"
	"io"
	"os"
)

// todo: 读取文件名称
func OpenClose() {
	f, err := os.Open("testa.txt")
	if err != nil {
		fmt.Printf("err: %v\n", err)
	} else {
		fmt.Printf("f.Name(): %v\n", f.Name())
		f.Close()
	}
}

// todo: 读取和创建文件
func OpenFileTxt() {
	f, err := os.OpenFile("testa.txt", os.O_RDWR|os.O_CREATE, 755)
	if err != nil {
		fmt.Printf("err: %v\n", err)
	} else {
		fmt.Printf("f.Name(): %v\n", f.Name())
		f.Close()
	}
}

// todo: 读文件
func readOps() {
	// * f.ReadAt(buf,3)   从第四个开始读
	f, _ := os.Open("testa.txt")
	for {
		buf := make([]byte, 10)
		n, err := f.Read(buf)
		if err == io.EOF { // io.EOF 表示读取文件结束的错误
			break
		}
		fmt.Printf("n: %v\n", n)
		fmt.Printf("string(bft): %v\n", string(buf))
	}
	f.Close()
}

// todo: 读文件夹
func readDir() {
	dir, _ := os.ReadDir("dao") // 读取的是dao下面的内容
	for _, v := range dir {
		fmt.Printf("v.IsDir(): %v\n", v.IsDir()) // 是文件夹 返回true 否则返回false
		fmt.Printf("v.Name(): %v\n", v.Name())   // 名称
	}
}

// todo: 随机读文件内容
func seekTxt() {
	f, _ := os.Open("testa.txt")
	f.Seek(3, 0) // 从第4个字开始读 读10个
	buf := make([]byte, 10)
	n, _ := f.Read(buf)
	fmt.Printf("n: %v\n", n)
	fmt.Printf("string(bft): %v\n", string(buf))
	f.Close()
}
func TestReadMain() {
	seekTxt()
}

package main

import "go3/mos"

func main() {
	mos.TestReadMain()
}

package mos

import "os"

func write() {
	// os.O_RDWR 读写权限
	// os.O_APPEND 在原先内容的基础上追加内容
	// os.O_TRUNC  覆盖
	f, _ := os.OpenFile("test.txt", os.O_RDWR|os.O_TRUNC, 0777)
	f.Write([]byte("hello javascript!"))
	f.Close()
}

func writeString() {
	// writeAt([]byte("aaaa",3))  // 从第四个字开始写入aaaa
	// 以上等同于write()
	// WriteString 其实就是 f.Write([]byte("hello javascript!"))
	f, _ := os.OpenFile("test.txt", os.O_RDWR|os.O_TRUNC, 0777)
	f.WriteString("hello typescript!")
	f.Close()
}
func TestWriteMain() {
	writeString()
}

package main

import "go3/mos"

func main() {
	mos.TestWriteMain()
}

type ProcAttr struct {
    Dir   string
    Env   []string
    Files []*os.File
    Sys   *syscall.SysProcAttr
}

package main

import (
    "fmt"
    "os"
)

func main() {
    cmd := "/path/to/myprogram"
    args := []string{"arg1", "arg2"}

    attr := &os.ProcAttr{
        Dir:   "/path/to/myprogram/dir",
        Files: []*os.File{os.Stdin, os.Stdout, os.Stderr},
    }

    proc, err := os.StartProcess(cmd, args, attr)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }

    fmt.Println("New process ID:", proc.Pid)
}

package mos

import (
	"fmt"
	"os"
	"time"
)

func TestProcessMain() {
	// 获取当前正在运行的进程id
	fmt.Printf("os.Getpid(): %v\n", os.Getpid())
	// 父id
	fmt.Printf("os.Getppid(): %v\n", os.Getppid())
	// 设置新进程的属性
	attr := &os.ProcAttr{
		// files指定新进程继承的活动文件对象
		// 前三个分别为,标准输入,标准输出,标准错误输出
		Files: []*os.File{os.Stdin, os.Stdout, os.Stderr},
		//新进程的环境变量
		Env: os.Environ(),
	}
	cmd := "/bin/ls"

	args := []string{"ls", "-l"}

	// 开始一个新进程
	p, err := os.StartProcess(cmd, args, attr)
	if err != nil {
		fmt.Printf("err:%v\n", err)
	}
	fmt.Println(p)
	fmt.Println("进程ID:", p.Pid)

	// 通过进程id查找进程
	p2, _ := os.FindProcess(p.Pid)
	fmt.Println("======", p2)

	fmt.Printf("---------\n")
	// 等待10秒,执行函数
	time.AfterFunc(time.Second*10, func() {
		// 向p进程发生退出信息
		p.Signal(os.Kill)
	})

	// 等待进程p的退出,返回进程状态
	ps, _ := p.Wait()
	fmt.Println("ps:", ps.String())
}

package main

import "go3/mos"

func main() {
	mos.TestProcessMain()
}

package mio

import (
	"fmt"
	"io"
	"log"
	"os"
	"strings"
)

func testNewReader() {
	r := strings.NewReader("hello javascript")
	buf := make([]byte, 10)
	r.Read(buf)
	fmt.Printf("string(buf): %v\n", string(buf))
}
func testCopy() {
	r := strings.NewReader("hello world")

	_, err := io.Copy(os.Stdout, r) //os.Stdout 表示在终端输出
	if err != nil {
		log.Fatal(err)
	}
}

// 带缓冲的buffer去读取内容 这个更快
func testCopyBuffer() {
	r1 := strings.NewReader("first reader hello javascript\n")
	r2 := strings.NewReader("second reader hello golang\n")
	buf := make([]byte, 8)

	if _, err := io.CopyBuffer(os.Stdout, r1, buf); err != nil {
		log.Fatal(err)
	}

	if _, err := io.CopyBuffer(os.Stdout, r2, buf); err != nil {
		log.Fatal(err)
	}
}

func testPipe() {
	r, w := io.Pipe()

	go func() {
		fmt.Fprint(w, "some io.Reader stream to be read\n")
		w.Close()
	}()

	if _, err := io.Copy(os.Stdout, r); err != nil {
		log.Fatal(err)
	}
}
func TestIoMain() {
	//* io.MultiReader(r1,r2,r3) 一次读取多个
	//* io.NewSectionReader(r,5,15) 读5-17

	// testCopyBuffer()
	testPipe()
}

package main

import (
	"go3/mio"
)

func main() {
	mio.TestIoMain()
}