单通道并发机制

communicating sequential processes (CSP)机制的提出非常古老(在1978年),它不同于erlang的actor model。go语言实现的CSP使用的通道会让消息的发送与接收更加解耦。

一、go语言的channel机制

1、阻塞式

单通道并发机制_第1张图片

接收者与发送者必须都在才能完成消息的发送与接收,如果发送者不在,接收者就必须等待,如果接收者不在,发送者也必须等待

2、非阻塞式
单通道并发机制_第2张图片

这种被称为buffer channel,是更加松耦合的实现方式,发送者与接收者各自独立,只要消息队列未满,发送者可以一直向channel中写入msg,只要消息队列不空,接收者可以一直从channel中取msg。

二、代码实现

串行执行

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

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

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

输出:

Done
working on sth else
Task is done

使用channel改造成CSP:

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

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

执行结果:

working on sth else
return result
Task is done Done
service exited

由于是阻塞式的,所以发送者一直等接收者取走msg之后才退出,所有最后才打印"service exited"

改造成非阻塞式的:

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

输出结果:

working on sth else
return result
service exited
Task is done
Done

发送者完成消息发送就退出了

你可能感兴趣的:(csp,channel)