init

Author: rushuinet

.gitignore

@@ -0,0 +1,2 @@
+
+go.sum

_/test.go

@@ -0,0 +1,41 @@
+package main
+
+import "fmt"
+
+type ITest interface {
+	Add() string
+	Bb() string
+}
+
+type A struct {
+
+}
+
+func (a *A)Add() string  {
+	return "A"
+}
+
+type B struct {
+
+}
+
+func (b *B)Add() string {
+	return "bb"
+}
+
+func (b *B)Bb() string {
+	return "bba"
+}
+
+
+var _ ITest = (*A)(nil)
+var _ ITest = (*B)(nil)
+
+var _ ITest = &A{}
+var _ ITest = &B{}
+
+func main()  {
+	a := &A{}
+	as := a.Add()
+	fmt.Println(as)
+}

buffer/test.go

@@ -0,0 +1,99 @@
+package main
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+)
+
+func main() {
+	//newBuffer 整形转换成字节
+	var n int = 10000
+	intToBytes := IntToBytes(n)
+	fmt.Println("==========int to bytes========")
+	fmt.Println(intToBytes)
+	//NewBufferString
+	TestBufferString()
+	//write
+	BufferWrite()
+	//WriteString
+	BufferWriteString()
+	//WriteByte
+	BufferWriteByte()
+	//WriteRune
+	BufferWriteRune()
+
+}
+
+
+func IntToBytes(n int) []byte {
+	x := int32(n)
+	//创建一个内容是[]byte的slice的缓冲器
+	//与bytes.NewBufferString("")等效
+	bytesBuffer := bytes.NewBuffer([]byte{})
+	binary.Write(bytesBuffer, binary.BigEndian, x)
+	return bytesBuffer.Bytes()
+}
+
+func TestBufferString(){
+	buf1:=bytes.NewBufferString("swift")
+	buf2:=bytes.NewBuffer([]byte("swift"))
+	buf3:=bytes.NewBuffer([]byte{'s','w','i','f','t'})
+	fmt.Println("===========以下buf1,buf2,buf3等效=========")
+	fmt.Println("buf1:", buf1)
+	fmt.Println("buf2:", buf2)
+	fmt.Println("buf3:", buf3)
+	fmt.Println("===========以下创建空的缓冲器等效=========")
+	buf4:=bytes.NewBufferString("")
+	buf5:=bytes.NewBuffer([]byte{})
+	fmt.Println("buf4:", buf4)
+	fmt.Println("buf5:", buf5)
+}
+
+func BufferWrite(){
+	fmt.Println("===========以下通过Write把swift写入Learning缓冲器尾部=========")
+	newBytes := []byte("swift")
+	//创建一个内容Learning的缓冲器
+	buf := bytes.NewBuffer([]byte("Learning"))
+	//打印为Learning
+	fmt.Println(buf.String())
+	//将newBytes这个slice写到buf的尾部
+	buf.Write(newBytes)
+	fmt.Println(buf.String())
+}
+
+func BufferWriteString(){
+	fmt.Println("===========以下通过Write把swift写入Learning缓冲器尾部=========")
+	newString := "swift"
+	//创建一个string内容Learning的缓冲器
+	buf := bytes.NewBufferString("Learning")
+	//打印为Learning
+	fmt.Println(buf.String())
+	//将newString这个string写到buf的尾部
+	buf.WriteString(newString)
+	fmt.Println(buf.String())
+}
+
+func BufferWriteByte(){
+	fmt.Println("===========以下通过WriteByte把swift写入Learning缓冲器尾部=========")
+	var newByte byte = '!'
+	//创建一个string内容Learning的缓冲器
+	buf := bytes.NewBufferString("Learning")
+	//打印为Learning
+	fmt.Println(buf.String())
+	//将newString这个string写到buf的尾部
+	buf.WriteByte(newByte)
+	fmt.Println(buf.String())
+}
+
+func BufferWriteRune(){
+	fmt.Println("===========以下通过WriteRune把\"好\"写入Learning缓冲器尾部=========")
+	var newRune = '好'
+	//创建一个string内容Learning的缓冲器
+	buf := bytes.NewBufferString("Learning")
+	//打印为Learning
+	fmt.Println(buf.String())
+	//将newString这个string写到buf的尾部
+	buf.WriteRune(newRune)
+	fmt.Println(buf.String())
+}

c/test.go

@@ -0,0 +1,15 @@
+package main
+
+/*
+#include <stdio.h>
+int Add(int a,int b) {
+    return a+b;
+}
+*/
+import "C"
+
+import "fmt"
+
+func main() {
+	fmt.Println(C.Add(1,2))
+}

context/cancel.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"time"
+)
+
+func main() {
+	// 手动取消
+	a := 1
+	b := 2
+	ctx, cancel := context.WithCancel(context.Background())
+	go func() {
+		time.Sleep(2 * time.Second)
+		cancel() // 在调用处主动取消
+	}()
+	res := Add(ctx, 1, 2)
+	fmt.Printf("Compute: %d+%d, result: %d\n", a, b, res)
+}

context/test.go

@@ -0,0 +1,63 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"time"
+)
+
+// 模拟一个最小执行时间的阻塞函数
+func inc(a int) int {
+	res := a + 1                // 虽然我只做了一次简单的 +1 的运算,
+	time.Sleep(1 * time.Second) // 但是由于我的机器指令集中没有这条指令,
+	// 所以在我执行了 1000000000 条机器指令, 续了 1s 之后, 我才终于得到结果。B)
+	return res
+}
+
+// 向外部提供的阻塞接口
+// 计算 a + b, 注意 a, b 均不能为负
+// 如果计算被中断, 则返回 -1
+func Add(ctx context.Context, a, b int) int {
+	res := 0
+	for i := 0; i < a; i++ {
+		res = inc(res)
+		select {
+		case <-ctx.Done():
+			return -1
+		default:
+		}
+	}
+	for i := 0; i < b; i++ {
+		res = inc(res)
+		select {
+		case <-ctx.Done():
+			return -1
+		default:
+		}
+	}
+	return res
+}
+
+func main() {
+	{
+		// 使用开放的 API 计算 a+b
+		a := 1
+		b := 2
+		timeout := 2 * time.Second
+		ctx, _ := context.WithTimeout(context.Background(), timeout)
+		res := Add(ctx, a, b)
+		fmt.Printf("Compute: %d+%d, result: %d\n", a, b, res)
+	}
+	{
+		// 手动取消
+		a := 5
+		b := 2
+		ctx, cancel := context.WithCancel(context.Background())
+		go func() {
+			time.Sleep(2 * time.Microsecond)
+			cancel() // 在调用处主动取消
+		}()
+		res := Add(ctx, a, b)
+		fmt.Printf("Compute2: %d+%d, result: %d\n", a, b, res)
+	}
+}

context/test1.go

@@ -0,0 +1,23 @@
+package main
+
+import (
+	"context"
+	"fmt"
+)
+
+func main() {
+	ctx, cancel := context.WithCancel(context.Background())
+
+	go func() {
+		// ...
+		// 你的逻辑
+		// ...
+		fmt.Println("1")
+		select {
+		case <-ctx.Done():
+		}
+	}()
+	fmt.Println("aa")
+	cancel()
+	fmt.Println("2")
+}

context/test2.go

@@ -0,0 +1,29 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"time"
+)
+
+func main() {
+	ctx, cancel := context.WithTimeout(context.TODO(), time.Second*5)
+	defer cancel()
+	go task(ctx)
+	time.Sleep(time.Second * 10)
+}
+
+func task(ctx context.Context) {
+	ch := make(chan struct{}, 0)
+	go func() {
+		// 模拟4秒耗时任务
+		time.Sleep(time.Second * 4)
+		ch <- struct{}{}
+	}()
+	select {
+	case <-ch:
+		fmt.Println("done")
+	case <-ctx.Done():
+		fmt.Println("timeout")
+	}
+}

context/test3.go

@@ -0,0 +1,24 @@
+package main
+
+import (
+	"context"
+	"fmt"
+)
+
+func main() {
+	type favContextKey string
+
+	f := func(ctx context.Context, k favContextKey) {
+		if v := ctx.Value(k); v != nil {
+			fmt.Println("found value:", v)
+			return
+		}
+		fmt.Println("key not found:", k)
+	}
+
+	k := favContextKey("language")
+	ctx := context.WithValue(context.Background(), k, "Go")
+
+	f(ctx, k)
+	f(ctx, favContextKey("color"))
+}

context/test4.go

@@ -0,0 +1,40 @@
+package main
+
+import (
+	"context"
+	"fmt"
+	"time"
+)
+
+func monitor(ctx context.Context, number int)  {
+	for {
+		select {
+		// 其实可以写成 case <- ctx.Done()
+		// 这里仅是为了让你看到 Done 返回的内容
+		case v :=<- ctx.Done():
+			fmt.Printf("监控器%v，接收到通道值为：%v，监控结束。\n", number,v)
+			return
+		default:
+			fmt.Printf("监控器%v，正在监控中...\n", number)
+			time.Sleep(2 * time.Second)
+		}
+	}
+}
+
+func main() {
+	ctx, cancel := context.WithCancel(context.Background())
+
+	for i :=1 ; i <= 5; i++ {
+		go monitor(ctx, i)
+	}
+
+	time.Sleep( 1 * time.Second)
+	// 关闭所有 goroutine
+	cancel()
+
+	// 等待5s，若此时屏幕没有输出 <正在监控中> 就说明所有的goroutine都已经关闭
+	time.Sleep( 5 * time.Second)
+
+	fmt.Println("主程序退出！！")
+
+}

cron/test.go

@@ -0,0 +1,20 @@
+package main
+
+import (
+	"github.com/robfig/cron"
+	"log"
+)
+
+func main() {
+	i := 0
+	c := cron.New()
+	spec := "*/5 * * * * ?"
+	c.AddFunc(spec, func() {
+		i++
+		log.Println("cron running :", i)
+	})
+	c.Start()
+	select {
+
+	}
+}