Go语言条件变量的两个例子

      在Go语言中 sync.Cond 代表条件变量，但它需要配置锁才能有用.
var m Mutex 

c := NewCond(&m)

或

c := sync.NewCond(&sync.RWMutex{})

之类.

它有三个函数: wait/signal/broadcast 

望文知义,和Windows下的InitializeConditionVariable与WaitForSingleObject()之类，

及Linux下的pthread_cond_t等作用差不多.

弄了两个例子:

/*
条件变量 Cond 例子

Author: xcl
Date: 2015-11-29
*/

package main

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

func main() {

runtime.GOMAXPROCS(4)

test333()
}

func testCond() {

c := sync.NewCond(&sync.Mutex{})
condition := false

go func() {
time.Sleep(time.Second * 1)
c.L.Lock()
fmt.Println("[1] 变更condition状态,并发出变更通知.")
condition = true
c.Signal() //c.Broadcast()
fmt.Println("[1] 继续后续处理.")
c.L.Unlock()

}()

c.L.Lock()
fmt.Println("[2] condition..........1")
for !condition {
fmt.Println("[2] condition..........2")
//等待Cond消息通知
c.Wait()
fmt.Println("[2] condition..........3")
}
fmt.Println("[2] condition..........4")
c.L.Unlock()

fmt.Println("main end...")
}

/*

testCond()运行结果:

[2] condition..........1
[2] condition..........2
[1] 变更condition状态,并发出变更通知.
[1] 继续后续处理.
[2] condition..........3
[2] condition..........4
main end...

*/

例二:

/*
条件变量 Cond 例子

Author: xcl
Date: 2015-11-29
*/

package main

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

const MAX_CLIENTS = 3

func main() {
runtime.GOMAXPROCS(4)

testCond()
}

func testCond() {
s := NewServer()
go s.IOloop()

time.Sleep(time.Second * 1)
go func() {
s.Release()
}()

go func() {
s.Release()
}()

time.Sleep(time.Second * 1)
s.Release()
time.Sleep(time.Second * 1)
fmt.Println("[testCond] end.")
}

type Server struct {
clients uint64
cond    *sync.Cond
}

func NewServer() *Server {
s := &Server{}
s.cond = sync.NewCond(&sync.Mutex{})
return s
}

func (s *Server) IOloop() {
for {
s.cond.L.Lock()
for s.clients == MAX_CLIENTS {
fmt.Println("[IOloop] 等于MAX_CLIENTS了,等待Cond通知.即有触发Release()")
s.cond.Wait()
}
s.cond.L.Unlock()
s.clients++
fmt.Println("[IOloop] clients:", s.clients)
}
}

func (s *Server) Release() {
s.cond.L.Lock()
s.clients--
fmt.Println("[Release] a clients:", s.clients)
s.cond.Signal()
fmt.Println("[Release] b clients:", s.clients)
s.cond.L.Unlock()

}

/*
运行结果:

[IOloop] clients: 1
[IOloop] clients: 2
[IOloop] clients: 3
[IOloop] 等于MAX_CLIENTS了,等待Cond通知.即有触发Release()
[Release] a clients: 2
[Release] b clients: 2
[Release] a clients: 1
[Release] b clients: 1
[IOloop] clients: 2
[IOloop] clients: 3
[IOloop] 等于MAX_CLIENTS了,等待Cond通知.即有触发Release()
[Release] a clients: 2
[Release] b clients: 2
[IOloop] clients: 3
[IOloop] 等于MAX_CLIENTS了,等待Cond通知.即有触发Release()
[testCond] end.

*/

对于条件变量和channl，知乎有个问答很精彩，可以看看: http://www.zhihu.com/question/27256570

另外 <<Go语言并发编程>>中也有个同一时间多个Goroutine分别进行对一个文件进行读写操作的例子也很精彩，直观。

噢，对了，附上C++11条件变量的使用例子:

// condition_variable example
#include <iostream> // std::cout
#include <thread> // std::thread
#include <mutex> // std::mutex, std::unique_lock
#include <condition_variable> // std::condition_variable

std::mutex mtx;
std::condition_variable cv;
bool ready = false;

void print_id (int id) {
std::unique_lock<std::mutex> lck(mtx);
while (!ready) cv.wait(lck);
// ...
std::cout << "thread " << id << '\n';
}

void go() {
std::unique_lock<std::mutex> lck(mtx);
ready = true;
cv.notify_all();
}

int main ()
{
std::thread threads[10];
// spawn 10 threads:
for (int i=0; i<10; ++i)
threads[i] = std::thread(print_id,i);

std::cout << "10 threads ready to race...\n";
go(); // go!

for (auto& th : threads) th.join();

return 0;
}
C++11例子来自: http://www.cplusplus.com/reference/condition_variable/condition_variable/

BLOG: http://blog.csdn.net/xcl168