Go语言学习笔记-并发编程-CSP并发机制

Actor Model

CSP vs Actor

1. 和Actor的直接通讯不同，CSP模式则是通过Channel进行通讯的，更松耦合一些。
2. Go中的Channel是有容量限制并且独立于处理Groutine，而如Erlang，Actor模式中的mailbox容量是无限的，接收进程也总是被动的处理消息。Groutine是主动处理消息

package concurrency

import (
    "fmt"
    "testing"
    "time"
)

func service() string {
    time.Sleep(time.Millisecond * 50)
    return "Done"
}

func otherTask() {
    fmt.Println("working on something else")
    time.Sleep(time.Millisecond * 100)
    fmt.Println("Task is done.")
}

func TestService(t *testing.T) {
    fmt.Println(service())
    otherTask()
}

func AsyncService() chan string {
    retCh := make(chan string, 1)
    //retCh := make(chan string, 1)
    go func() {
        ret := service()
        fmt.Println("returned result.")
        retCh <- ret
        fmt.Println("service exited.")
    }()
    return retCh
}

//
func TestAsynService(t *testing.T) {
    retCh := AsyncService()
    otherTask()
    fmt.Println(<-retCh)
    time.Sleep(time.Second * 1)
}

select 多路选择，超时控制

package select_test

import (
    "fmt"
    "testing"
    "time"
)

func service() string {
    time.Sleep(time.Millisecond * 500)
    return "Done"
}

func AsyncService() chan string {
    retCh := make(chan string, 1)
    //retCh := make(chan string, 1)
    go func() {
        ret := service()
        fmt.Println("returned result.")
        retCh <- ret
        fmt.Println("service exited.")
    }()
    return retCh
}

func TestSelect(t *testing.T) {
    select {
    case ret := <-AsyncService():
        t.Log(ret)
    case <-time.After(time.Millisecond * 100):
        t.Error("time out")
    }
}