Golang极速上手

1
2
3
4
5
6
7

// 多行申明
type User struct{
	 Username string
	 Email string
}
// 多行初始化
u := User{ Username: "bobby", Email: "bobby@imooc.com", }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

//定义一个鸟类型
type Bird struct {
 ...
}
//鸟类型的方法
func (b *Bird) Fly() {
 // 以鸟的方式飞行
}

//定义一个IFly接口
type IFly interface {
	Fly()
}

//使用接口
func main() {
    var fly IFly = new(Bird)
    fly.Fly()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

//由两个goroutine进行并行的累加计算，待这两个计算过程都完成后打印计算结果
package main
import "fmt"
func sum(values [] int, resultChan chan int) {
    sum := 0
    for _, value := range values {
        sum += value
    }
    resultChan <- sum // 将计算结果发送到channel中
}
func main() {
    values := [] int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
    resultChan := make(chan int, 2)
    go sum(values[:len(values)/2], resultChan)
    go sum(values[len(values)/2:], resultChan)
    sum1, sum2 := <-resultChan, <-resultChan // 接收结果
    fmt.Println("Result:", sum1, sum2, sum1 + sum2)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

//以利用反射功能列出某个类型中所有成员变量的值
package main
import (
    "fmt"
    "reflect"
)
type Bird struct {
    Name string
    LifeExpectance int
}
func (b *Bird) Fly() {
    fmt.Println("I am flying...")
}
func main() {
    sparrow := &Bird{"Sparrow", 3}
    s := reflect.ValueOf(sparrow).Elem()
    typeOfT := s.Type()
    for i := 0; i < s.NumField(); i++ {
        f := s.Field(i)
        fmt.Printf("%d: %s %s = %v\n", i,typeOfT.Field(i).Name,f.Type(),
                   f.Interface())
    }
}

1
2
3
4
5

package main
import "fmt"// 我们需要使用fmt包中的Println()函数
func main() {
	fmt.Println("Hello, world. 你好，世界！")
}

1
2
3

func Compute(value1 int, value2 float64) (result float64, err error) {
 // 函数体
}

1

 go run hello.go

1

 go build hello.go

1
2
3
4
5
6
7
8
9

$ calc help
USAGE: calc command [arguments] ...
The commands are:
sqrt Square root of a non-negative value.
add Addition of two values.
$ calc sqrt 4 # 开根号
2
$ calc add 1 2 # 加法
3

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

一个正常的工程目录组织应该如下所示：
<calcproj>
├─<src>
 ├─<calc>
 ├─calc.go
 ├─<simplemath>
 ├─add.go
 ├─add_test.go
 ├─sqrt.go
 ├─sqrt_test.go
├─<bin>
├─<pkg>＃包将被安装到此处

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

//calc.go
package main

import "os" // 用于获得命令行参数os.Args
import "fmt"
import "simplemath"
import "strconv"

var Usage = func() {
	fmt.Println("USAGE: calc command [arguments] ...")
	fmt.Println("\nThe commands are:\n\tadd\tAddition of two values.\n\tsqrt\tSquar root of a non - negative value.")
}

func main() {
	args := os.Args
	if args == nil || len(args) < 2 {
		Usage()
		return
	}
	switch args[0] {
	case "add":
		if len(args) != 3 {
			fmt.Println("USAGE: calc add <integer1><integer2>")
			return
		}
		v1, err1 := strconv.Atoi(args[1])
		v2, err2 := strconv.Atoi(args[2])
		if err1 != nil || err2 != nil {
			fmt.Println("USAGE: calc add <integer1><integer2>")
			return
		}
		ret := simplemath.Add(v1, v2)
		fmt.Println("Result: ", ret)
	case "sqrt":
		if len(args) != 2 {
			fmt.Println("USAGE: calc sqrt <integer>")
			return
		}
		v, err := strconv.Atoi(args[1])
		if err != nil {
			fmt.Println("USAGE: calc sqrt <integer>")
			return
		}
		ret := simplemath.Sqrt(v)
		fmt.Println("Result: ", ret)
	default:
		Usage()
	}
}

1
2
3
4
5

// add.go
package simplemath
func Add(a int, b int) int {
	return a + b
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// add_test.go
package simplemath

import "testing"

func TestAdd1(t *testing.T) {
	r := Add(1, 2)
	if r != 3 {
		t.Errorf("Add(1, 2) failed. Got %d, expected 3.", r)
	}
}

1
2
3
4
5
6
7
8
9

// sqrt.go
package simplemath

import "math"

func Sqrt(i int) int {
	v := math.Sqrt(float64(i))
	return int(v)
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// sqrt_test.go
package simplemath

import "testing"

func TestSqrt1(t *testing.T) {
	v := Sqrt(16)
	if v != 4 {
		t.Errorf("Sqrt(16) failed. Got %v, expected 4.", v)
	}
}

1
2
3

cd /calcproj
mkdir bin
go build calc

1

go test simplemath

1

gdb calc

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

var v1 int
var v2 string
var v3 [10]int	//数组
var v4 []int	//数组切片
var v5 struct{
    f int
}
var v6 *int		//指针
var v7 map[string] int		//map   key为string value为int
var v8 func(a int) int		// 匿名函数

//将若干个变量声明在一起，避免了重复写var
var (
	v1 int
	v2 string
)

1
2
3

var v1 int = 10 // 正确的使用方式1
var v2 = 10 // 正确的使用方式2，编译器可以自动推导出v2的类型
v3 := 10 // 正确的使用方式3，编译器可以自动推导出v3的类型

1

i,j=j,i

1
2
3
4
5

func GetName() (firstName, lastName, nickName string) {
	return "May", "Chan", "Chibi Maruko"
}

_,_,nickName := GetName()

1
2
3
4
5

-12
3.14159265358979323846 // 浮点类型的常量
3.2+12i // 复数类型的常量
true // 布尔类型的常量
"foo" // 字符串常量

1
2
3
4
5
6
7
8
9

const Pi float64 = 3.14159265358979323846
const zero = 0.0 // 无类型浮点常量
const (
 size int64 = 1024
 eof = -1 // 无类型整型常量
)
const u, v float32 = 0, 3 // u = 0.0, v = 3.0，常量的多重赋值
const a, b, c = 3, 4, "foo"
// a = 3, b = 4, c = "foo", 无类型整型和字符串常量

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

const ( // iota被重设为0
	c0 = iota // c0 == 0
	c1 = iota // c1 == 1
	c2 = iota // c2 == 2
)
const (
	a = 1 << iota // a == 1 (iota在每个const开头被重设为0)
	b = 1 << iota // b == 2
	c = 1 << iota // c == 4
)
const (
	u         = iota * 42 // u == 0
	v float64 = iota * 42 // v == 42.0 w = iota * 42 // w == 84
)
const x = iota // x == 0 (因为iota又被重设为0了)
const y = iota // y == 0 (同上)


const ( // iota被重设为0
	c0 = iota // c0 == 0
	c1        // c1 == 1
	c2        // c2 == 2
)
const (
	a = 1 << iota // a == 1 (iota在每个const开头被重设为0)
	b             // b == 2
	c             // c == 4
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

const (
	Sunday = iota
	Monday
	Tuesday
	Wednesday
	Thursday
	Friday
	Saturday
	numberOfDays // 这个常量没有导出 包内私有
)

1
2
3

var value2 int32
value1:=64
value2=int32(value1)

1
2
3
4

var value1 complex64	// 由2个float32构成的复数类型
value1 = 3.2 + 12i
value2 := 3.2 + 12i 	// value2是complex128类型
value3 := complex(3.2, 12) // value3结果同 value2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

str := "Hello,世界"
for i, ch := range str {
 fmt.Println(i, ch)//ch的类型为rune
}

str := "Hello,世界"
n := len(str)
for i := 0; i < n; i++ {
 ch := str[i] // 依据下标取字符串中的字符，类型为byte
 fmt.Println(i, ch)
}

1
2
3
4
5
6

//声明方式
[32]byte // 长度为32的数组，每个元素为一个字节
[2*N] struct { x, y int32 } // 复杂类型数组
[1000]*float64 // 指针数组
[3][5]int // 二维数组
[2][2][2]float64 // 等同于[2]([2]([2]float64))

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

// 先定义一个数组
 var myArray [10]int = [10]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
 // 基于数组创建一个数组切片
 var mySlice []int = myArray[:5]
 fmt.Println("Elements of myArray: ")
 for _, v := range myArray {
 fmt.Print(v, " ")
 }
 fmt.Println("\nElements of mySlice: ")
 for _, v := range mySlice {
 fmt.Print(v, " ")
 }

//直接创建
//创建一个初始元素个数为5的数组切片，元素初始值为0：
mySlice1 := make([]int, 5)
//创建一个初始元素个数为5的数组切片，元素初始值为0，并预留10个元素的存储空间：
mySlice2 := make([]int, 5, 10)
//直接创建并初始化包含5个元素的数组切片：
mySlice3 := []int{1, 2, 3, 4, 5}

1
2
3
4
5
6
7

mySlice2 := []int{8, 9, 10}
myslice := make([]int, 5, 10)
myslice = append(myslice, 8, 9, 10)
// 给mySlice后面添加另一个数组切片
mySlice = append(mySlice, mySlice2...)
//上句等价于
mySlice = append(mySlice, 8, 9, 10)

1
2
3
4

slice1 := []int{1, 2, 3, 4, 5}
slice2 := []int{5, 4, 3}
copy(slice2, slice1) // 只会复制slice1的前3个元素到slice2中
copy(slice1, slice2) // 只会复制slice2的3个元素到slice1的前3个位置

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

package main

import "fmt"

// PersonInfo是一个包含个人详细信息的类型
type PersonInfo struct {
	ID      string
	Name    string
	Address string
}

func main() {
	var personDB map[string]PersonInfo
	personDB = make(map[string]PersonInfo)
	// 往这个map里插入几条数据
	personDB["12345"] = PersonInfo{"12345", "Tom", "Room 203,..."}
	personDB["1"] = PersonInfo{"1", "Jack", "Room 101,..."}
	// 从这个map查找键为"1234"的信息
	person, ok := personDB["1234"]
	// ok是一个返回的bool型，返回true表示找到了对应的数据
	if ok {
		fmt.Println("Found person", person.Name, "with ID 1234.")
	} else {
		fmt.Println("Did not find person with ID 1234.")
	}
}

1

var myMap map[string] PersonInfo

1
2
3
4
5
6

myMap = make(map[string] PersonInfo)
myMap = make(map[string] PersonInfo, 100)//存储能力为100
//创建并初始化
myMap = map[string] PersonInfo{
 "1234": PersonInfo{"1", "Jack", "Room 101,..."},
}

1

myMap["1234"] = PersonInfo{"1", "Jack", "Room 101,..."}

1

delete(myMap, "1234")

1
2
3
4

value, ok := myMap["1234"]
if ok { // 找到了
 // 处理找到的value
}

1
2
3
4
5

if a < 5 {
 return 0
} else {
 return 1
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

switch i {
 case 0:
 fmt.Printf("0")
 case 1:
 fmt.Printf("1")
 case 2:
 fallthrough
 case 3:
 fmt.Printf("3")
 case 4, 5, 6:
 fmt.Printf("4, 5, 6")
 default:
 fmt.Printf("Default")
}

switch {
 case 0 <= Num && Num <= 3:
 fmt.Printf("0-3")
 case 4 <= Num && Num <= 6:
 fmt.Printf("4-6")
 case 7 <= Num && Num <= 9:
 fmt.Printf("7-9")
}

1
2
3
4

a := []int{1, 2, 3, 4, 5, 6}
for i, j := 0, len(a) – 1; i < j; i, j = i + 1, j – 1 {
 a[i], a[j] = a[j], a[i]
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

for j := 0; j < 5; j++ {
    for i := 0; i < 10; i++ {
        if i > 5 {
            break JLoop
        }
        fmt.Println(i)
    }
}
JLoop:
// ...

1
2
3
4
5
6
7
8
9

func myfunc() {
	i := 0
HERE:
	fmt.Println(i)
	i++
	if i < 10 {
		goto HERE
	}
}

1
2
3
4
5

func myfunc(args ...int) {
	for _, arg := range args {
	fmt.Println(arg)
	}
}

1
2
3

func Printf(format string, args ...interface{}) {
 // ...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

func MyPrintf(args ...interface{}) {
	for _, arg := range args {
		switch arg.(type) {
		case int:
			fmt.Println(arg, "is an int value.")
		case string:
			fmt.Println(arg, "is a string value.")
		case int64:
			fmt.Println(arg, "is an int64 value.")
		default:
			fmt.Println(arg, "is an unknown type.")
		}
	}
}

1
2
3
4
5
6

f := func(x, y int) int {
 return x + y
}
func(ch chan int) {
 ch <- ACK
} (reply_chan) // 花括号后直接跟参数列表表示函数调用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

package main

import (
	"fmt"
)

func main() {
	var j int = 5
	a := func() func() {
		var i int = 10
		return func() {
			fmt.Printf("i, j: %d, %d\n", i, j)
		}
	}()
	a()
	j *= 2
	a()
}

/*
结果：
i, j: 10, 5
i, j: 10, 10
*/

1
2
3

type error interface {
 Error() string
}

1
2
3
4
5

if err != nil {
 // 错误处理
} else {
 // 使用返回值n
}

1
2
3
4
5

type PathError struct {
	Op string
	Path string
	Err error
}

1
2
3

func (e *PathError) Error() string {
	return e.Op + " " + e.Path + ": " + e.Err.Error()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

package main

import (
    "fmt"
)

func divide() {
    defer func() {
        if err := recover(); err != nil {
            fmt.Printf("Runtime panic caught: %v\n", err)
        }
    }()

    var i = 1
    var j = 0
    k := i / j
    fmt.Printf("%d / %d = %d\n", i, j, k)
}

func main() {
    divide()
    fmt.Println("divide方法调用完毕，回到main函数")
}

1
2
3
4

type Integer int
func (a Integer) Less(b Integer) bool {
 return a < b
}

1
2
3
4
5
6
7

func (a *Integer) Add(b Integer) {
 *a += b
}

func (a Integer) Add(b Integer) {
 a += b
}

1
2
3
4
5
6
7
8

type Rect struct {
x, y float64
width, height float64
}

func (r *Rect) Area() float64 {
return r.width * r.height
}

1
2
3
4

rect1 := new(Rect)
rect2 := &Rect{}
rect3 := &Rect{0, 0, 100, 200}
rect4 := &Rect{width: 100, height: 200}

1
2
3

func NewRect(x, y, width, height float64) *Rect {
 return &Rect{x, y, width, height}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

type Base struct {
 Name string
}
func (base *Base) Foo() { ... }
func (base *Base) Bar() { ... }

type Foo struct {
 Base
 ...
}
func (foo *Foo) Bar() {
 foo.Base.Bar()
 ...
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

type File struct {
 // ...
}
func (f *File) Read(buf []byte) (n int, err error)
func (f *File) Write(buf []byte) (n int, err error)
func (f *File) Seek(off int64, whence int) (pos int64, err error)
func (f *File) Close() error

type IFile interface {
 Read(buf []byte) (n int, err error)
 Write(buf []byte) (n int, err error)
 Seek(off int64, whence int) (pos int64, err error)
 Close() error
}
type IReader interface {
 Read(buf []byte) (n int, err error)
}
type IWriter interface {
 Write(buf []byte) (n int, err error)
}
type ICloser interface {
 Close() error
}

var file1 IFile = new(File)
var file2 IReader = new(File)
var file3 IWriter = new(File)
var file4 ICloser = new(File)

1
2
3
4

var file1 Writer = ...
if file5, ok := file1.(two.IStream); ok {
 ...
}

1
2
3
4
5
6

var v1 interface{} = ...
switch v := v1.(type) {
 case int: // 现在v的类型是int
 case string: // 现在v的类型是string
 ...
}

1
2
3
4
5

var v1 interface{} = 1 // 将int类型赋值给interface{}
var v2 interface{} = "abc" // 将string类型赋值给interface{}
var v3 interface{} = &v2 // 将*interface{}类型赋值给interface{}
var v4 interface{} = struct{ X int }{1}
var v5 interface{} = &struct{ X int }{1}

1
2
3
4
5
6

func Add(x, y int) {
 z := x + y
 fmt.Println(z)
}

go Add(1,1)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

package main

import "fmt"

func Add(x, y int) {
	z := x + y
	fmt.Println(z)
}
func main() {
	for i := 0; i < 10; i++ {
		go Add(i, i)
	}
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

package main

import "fmt"

func Count(ch chan int) {
	ch <- 1
	fmt.Println("Counting")
}
func main() {
	chs := make([]chan int, 10)
	for i := 0; i < 10; i++ {
		chs[i] = make(chan int)
		go Count(chs[i])
	}
	for _, ch := range chs {
		<-ch
	}
}

1
2
3
4
5
6
7
8

var ch chan int
var m map[string] chan bool //声明一个map，key是string，value是channel
ch := make(chan int)

//写入数据
ch <- value
//读出数据
value := <-ch

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

package main

import "fmt"

func main(){
	var msg chan int
	msg = make(chan int)
	msg<- 1
	data := <- msg
	fmt.Println(data)
}
// 执行情况：fatal error: all goroutines are asleep - deadlock!

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

package main

import "fmt"

func main(){
	var msg chan int
	msg = make(chan int)
	go func() {
		data := <- msg
		fmt.Println(data)
	}()
	msg<- 1
}
//执行情况：啥也不会输出，正常结束

1
2
3
4
5
6
7
8

select {
	case <-chan1:
	// 如果chan1成功读到数据，则进行该case处理语句
	case chan2 <- 1:
		// 如果成功向chan2写入数据，则进行该case处理语句
	default:
		// 如果上面都没有成功，则进入default处理流程
	}

1

c := make(chan int, 1024)

1

i:= <-ch

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

timeout := make(chan bool, 1)
go func() {
 time.Sleep(1e9) // 等待1秒钟
 timeout <- true
}()
// 然后我们把timeout这个channel利用起来
select {
 case <-ch:
 // 从ch中读取到数据
 case <-timeout:
 // 一直没有从ch中读取到数据，但从timeout中读取到了数据
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

type PipeData struct {
    value   int
    handler func(int) int
    next    chan int
}

func handle(queue chan *PipeData) {
    for data := range queue {
        data.next <- data.handler(data.value)
    }
}

1
2
3

var ch1 chan int // ch1是一个正常的channel，不是单向的
var ch2 chan<- float64// ch2是单向channel，只用于写float64数据
var ch3 <-chan int // ch3是单向channel，只用于读取int数据

1
2
3

ch4 := make(chan int)
ch5 := <-chan int(ch4) // ch5就是一个单向的读取channel
ch6 := chan<- int(ch4) // ch6 是一个单向的写入channel

1

close(ch)

1

x,ok := <- ch

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

type Vector []float64

// 分配给每个CPU的计算任务
func (v Vector) DoSome(i, n int, u Vector, c chan int) {
	for ; i < n; i++ {
		v[i] += u.Op(v[i])
	}
	c <- 1 // 发信号告诉任务管理者我已经计算完成了
}

const NCPU = 16 // 假设总共有16核
func (v Vector) DoAll(u Vector) {
	c := make(chan int, NCPU) // 用于接收每个CPU的任务完成信号
	for i := 0; i < NCPU; i++ {
		go v.DoSome(i*len(v)/NCPU, (i+1)*len(v)/NCPU, u, c)
	}
	// 等待所有CPU的任务完成
	for i := 0; i < NCPU; i++ {
		<-c // 获取到一个数据，表示一个CPU计算完成了
	}
	// 到这里表示所有计算已经结束
}

1

runtime.GOMAXPROCS(16)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

var a string
var once sync.Once
func setup() {
 a = "hello, world"
}
func doprint() {
 once.Do(setup)
 print(a)
}
func twoprint() {
 go doprint()
 go doprint()
}

1

func CompareAndSwapUint64(val *uint64, old, new uint64) (swapped bool)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

package main

import (
    "fmt"
	"sync"
)

var wg sync.WaitGroup()


func handle(n int) {
    defer wg.Done()
    fmt.Println(n)
}

func main() {
    for i=0; i<=10; i++{
        wg.Add(1)
        go handle(i)
    }
    wg.Wait()
}
/*
WaitGroup是sync包中提供的，它可以让子协程执行完，主协程再死亡。从而达到优雅退出的效果。
注意：
	1. Add函数：开启几个子协程就需要执行几次该函数。
    2. Done函数：执行几次Add函数就需要执行几次Done函数。
    3. Wait函数：只执行一次，就是在子协程全部执行完成后。
*/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

package main

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

var rwLock sync.RWMutex
var wg sync.WaitGroup

func read(){
	defer wg.Done()
	rwLock.RLock()
	fmt.Println("读取数据")
	time.Sleep(time.Second)
	fmt.Println("读取成功")
	rwLock.RUnlock()
}

func write(){
	defer wg.Done()
	rwLock.Lock()
	fmt.Println("修改数据")
	time.Sleep(time.Second*10)
	fmt.Println("修改成功")
	rwLock.Unlock()
}

func main() {
	wg.Add(10)
	for i := 0;i<5;i++ {
		go read()
	}
	for i := 0;i<5;i++ {
		go write()
	}
	wg.Wait()
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

package main

import (
	"encoding/csv"
	"fmt"
	"os"
	"strconv"
	"sync"
	"time"
)

type Server struct {

}

func (server *Server) Connect() chan []string {

	session := make(chan []string, 128)
    //监听session
	go func(c chan []string) {
		file, _ := os.OpenFile("./test.csv", os.O_CREATE|os.O_TRUNC, 0666)
		defer file.Close()
		writer := csv.NewWriter(file)
		defer file.Close()
		for {
			strs := <-c
			if strs[0] == "CLOSE" {
				writer.Write(strs)
				writer.Flush()
				fmt.Println("结束通信")
				break
			}
			writer.Write(strs)
			writer.Flush()
		}

	}(session)

	fmt.Println("建立连接成功!")
	return session
}
func NewServer() *Server {

	return &Server{
   }
}

type Client struct {
	conn chan []string
}

func NewClient(server *Server) *Client {
    //建立客户端的同时，使用通道建立协程间的通信
	c := server.Connect()
	return &Client{c}
}

func (client *Client) Send(strs []string) {
	client.conn <- strs
}

var wp sync.WaitGroup

func main() {
	server := NewServer()
	client := NewClient(server)
	for i := 0; i < 10000; i++ {
		wp.Add(1)
		go func() {
			defer wp.Done()
			client.Send([]string{"hello", strconv.Itoa(i)})
		}()
	}
	//time.Sleep(time.Duration(1) * time.Second)
	wp.Wait()
	go client.Send([]string{"CLOSE"})
	time.Sleep(time.Duration(1) * time.Second)

}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

import "time"
import "fmt"
func main() {
    c1 := make(chan string, 1)
    go func() {
        time.Sleep(time.Second * 2)
        c1 <- "result 1"
    }()
    select {
    case res := <-c1:
        fmt.Println(res)
    case <-time.After(time.Second * 1):
        fmt.Println("timeout 1")
    }
}