go 多线程

goroutine Runtime包中提供了几个与goroutine相关的函数。Gosched()让目前正在执行的goroutine放弃CPU执行权限。调度器安排其他正在等待的线程。 请参见以下例子：

package mainimport (    "runtime"    "fmt")func main(){    go sayHello()    go sayWorld()    var str string    fmt.Scan(&str)}func sayHello(){    for i := 0; i < 10; i++{        fmt.Print("hello ")        runtime.Gosched()    }}func sayWorld(){    for i := 0; i < 10; i++ {        fmt.Println("world")        runtime.Gosched()    }}

从以上输出结果可以看出，我们启动了两个线程，其中一个线程输出一个句子，然后调用Gosched函数释放CPU权限；然后另一个线程获得CPU权限。这样，在输出上述结果之前，两个线程交替获得CPU权限。

runtime.NumCPU()返回cpu核数，runtime.NumGoroutine()返回当前流程的goroutine线程数。即使我们没有打开新的goroutine。

runtime.Goexit()函数用于终止当前的goroutine，单defer函数将继续调用。

package mainimport (    "runtime"    "fmt")func test(){    defer func(){        fmt.Println(" in defer")    }()    for i := 0; i < 10; i++{        fmt.Print(i)        if i > 5{            runtime.Goexit()        }    }}func main(){    go test()    var str string    fmt.Scan(&str)}

在这里，你可能会有一个问题。以下两个代码是干什么的？

var str string fmt.Scan(&str) 这两个代码意味着等待输入，以防止主线程关闭。如果没有这两句话，我们会发现我们的程序瞬间结束，没有输出。这是因为主线程关闭后，所有打开的goroutine都会被迫关闭，他还没来得及输出就结束了。 但是感觉很奇怪。如果有一个机制，最好在子线程结束时通知主线程，然后关闭主线程，这样你就不必无休止地等待。于是就有了channel。

channel goroutine通过chanel通信，可以认为chanel是一个管道或先进先出的队列。您可以从一个goroutine中向chanel发送数据，并在另一个goroutine中取出此值。 使用make创建

var channel chan int = make(chan int)// 或者channel := make(chan int)生产者/消费者是最经典的使用例子。生产者goroutine负责将数据放入chanel，消费者goroutine从chanel中取出数据进行处理。package mainimport (    "fmt")func main(){    buf:=make(chan int)    flg := make(chan int)    go producer(buf)    go consumer(buf, flg)    <-flg //等待接受完成func producer(c chan int){    defer close(c) // 关闭channel    for i := 0; i < 10; i++{        c <- i // 阻塞，直到数据被消费者取走，下一个数据才能发送    }}func consumer(c, f chan int){    for{        if v, ok := <-c; ok{            fmt.Print(v) // 阻塞，直到生产者放入数据后继续读取数据        }else{            break        }    }    f<-1 ///发送数据，通知main函数已完成}

运行结果

可将channel指定为单向通信。例如<-chan int只能接收，chan<-int只能发送。以前的生产者和消费者可以改为一种方式：

func producer(c chan<-int){    defer close(c) // 关闭channel    for i := 0; i < 10; i++{        c <- i // 直到数据被消费者取走，可以发送下一个数据    }}func consumer(c <-chan int, f chan<-int){    for{        if v, ok := <-c; ok{            fmt.Print(v) // 阻塞，直到生产者放入数据后继续读取数据        }else{            break        }    }    f<-1 //发送数据，通知main函数已完成}channle可以带缓冲。作为缓冲长度，make的第二个参数初始化为带缓冲的chanel:

c := make(chan int, 5) 将数据发送到带缓冲的chanel时，只有当缓冲区满时，发送操作才会被堵塞。只有当缓冲区空时，接收才会被堵塞。 发送和接收的顺序调试可通过以下程序进行调整

package mainimport (    "fmt")func main(){    c := make(chan int, 2)    c <- 1    c <- 2    fmt.Println(<-c)    fmt.Println(<-c)}

select 如果需要监控多个channel，可以考虑使用select随机处理可用channel

package mainimport (    "fmt")func main(){    c := make(chan int)    quit := make(chan int)    go func(){        for i := 0; i < 10; i++{            fmt.Printf("%d ", <-c)        }        quit <- 1    }()    testMuti(c, quit)}func testMuti(c, quit chan int){    x, y := 0, 1    for {        select{        case c<-x:            x, y = y, x+y        case <-quit:            fmt.Print("\nquit")            return        }    }}

channle超时机制 当channel被read/write阻塞时，它将被阻塞，直到chanel关闭。产生异常退出程序。channel内部没有加班定时器。但是我们可以使用select来实现channel的加班机制

package mainimport (    "time"    "fmt")func main(){    c := make(chan int)    select{    case <- c:        fmt.Println(“无数据”)    case <-time.After(5* time.Second):        fmt.Println(“超时退出”)    }}

线程同步

假设我们现在有两个线程，一个线程写文件，一个线程读文件。如果在阅读文件时将数据写入文件的线程，就会出现问题。为保证正确读写文件，在读写文件时，不能进行写入文件的操作，在写入时，不能进行读写操作。这就需要互斥锁。互斥锁是线程间同步的机制，保证同时只有一个线程访问共享资源。go中的互斥锁在sync包中。以下是线程安全的mapp:

package mainimport (    "errors"    "sync"    "fmt")func main(){    m := &MyMap{mp:make(map[string]int), mutex:new(sync.Mutex)}    go SetValue(m)    go m.Display()    var str string    fmt.Scan(&str)}type MyMap struct{    mp map[string]int    mutex *sync.Mutex}func (this *MyMap)Get(key string)(int, error){    this.mutex.Lock()    i, ok := this.mp[key]    this.mutex.Unlock()    if !ok{        return i, errors.New(“不存在”)    }    return i, nil}func (this *MyMap)Set(key string, val int){    this.mutex.Lock()    defer this.mutex.Unlock()    this.mp[key] = val}func (this *MyMap)Display(){    this.mutex.Lock()    defer this.mutex.Unlock()    for key, val := range this.mp{        fmt.Println(key, "=", val)    }}func SetValue(m *MyMap){    var a  rune    a = 'a'    for i := 0; i< 10; i++{        m.Set(string(a+rune(i)), i)    }}

运行结果

完