非并发的做法是这样的：

// 函数 rand_generator_1 ，返回 int
 func rand_generator_1() int {
 	return rand.Int()
 }

// 函数 rand_generator_2，返回 通道(Channel)
 func rand_generator_2() chan int {
 	// 创建通道
 	out := make(chan int)
 	// 创建协程
 	go func() {
 		for {
 			//向通道内写入数据，如果无人读取会等待
 			out <- rand.Int()
 		}
 	}()
 	return out
 }
 
 func main() {
 	// 生成随机数作为一个服务
 	rand_service_handler := rand_generator_2()
 	// 从服务中读取随机数并打印
 	fmt.Printf("%d\n",<-rand_service_handler)
 }

调用生成器，可以返回一个“服务”。可以用在持续获取数据的场合。用途很广泛，读取数据，生成ID，甚至定时器。这是一种非常简洁的思路，将程序并发化。

多路复用

多路复用是让一次处理多个队列的技术。Apache使用处理每个连接都需要一个进程，所以其并发性能不是很好。而Nighx使用多路复用的技术，让一个进程处理多个连接，所以并发性能比较好。同样，在协程的场合，多路复用也是需要的，但又有所不同。多路复用可以将若干个相似的小服务整合成一个大服务。

// 函数 rand_generator_3 ，返回通道(Channel)
 func rand_generator_3() chan int {
 	// 创建两个随机数生成器服务
 	rand_generator_1 := rand_generator_2()
 	rand_generator_2 := rand_generator_2()
 
 	//创建通道
 	out := make(chan int)
 
 	//创建协程
 	go func() {
 		for {
 			//读取生成器1中的数据，整合
 			out <- <-rand_generator_1
 		}
 	}()
 	go func() {
 		for {
 			//读取生成器2中的数据，整合
 			out <- <-rand_generator_2
 		}
 	}()
 	return out
 }

多路复用技术可以用来整合多个通道。提升性能和操作的便捷。配合其他的模式使用有很大的威力。

Furture技术

Furture是一个很有用的技术，我们常常使用Furture来操作线程。我们可以在使用线程的时候，可以创建一个线程，返回Furture，之后可以通过它等待结果。 但是在协程环境下的Furtue可以更加彻底，输入参数同样可以是Furture的。

//一个查询结构体
 type query struct {
 	//参数Channel
 	sql chan string
 	//结果Channel
 	result chan string
 }
 
 //执行Query
 func execQuery(q query) {
 	//启动协程
 	go func() {
 		//获取输入
 		sql := <-q.sql
 		//访问数据库，输出结果通道
 		q.result <- "get " + sql
 	}()
 
 }
 
 func main() {
 	//初始化Query
 	q :=
 		query{make(chan string,1),make(chan string,1)}
 	//执行Query，注意执行的时候无需准备参数
 	execQuery(q)
 
 	//准备参数
 	q.sql <- "select * from table"
 	//获取结果
 	fmt.Println(<-q.result)
 }

Furture技术可以和各个其他技术组合起来用。可以通过多路复用技术，监听多个结果Channel，当有结果后，自动返回。也可以和生成器组合使用，生成器不断生产数据，Furture技术逐个处理数据。Furture技术自身还可以首尾相连，形成一个并发的pipe filter。这个pipe filter可以用于读写数据流，操作数据流。

Future是一个非常强大的技术手段。可以在调用的时候不关心数据是否准备好，返回值是否计算好的问题。让程序中的组件在准备好数据的时候自动跑起来。

并发循环

循环往往是性能上的热点。如果性能瓶颈出现在CPU上的话，那么九成可能性热点是在一个循环体内部。所以如果能让循环体并发执行，那么性能就会提高很多。

//建立计数器
 sem := make(chan int,N); 
 //FOR循环体
 for i,xi := range data {
 	//建立协程
     go func (i int,xi float) {
         doSomething(i,xi);
 		//计数
         sem <- 0;
     } (i,xi);
 }
 // 等待循环结束
 for i := 0; i < N; ++i { <-sem }

上面是一个并发循环例子。通过计数器来等待循环全部完成。如果结合上面提到的Future技术的话，则不必等待。可以等到真正需要的结果的地方，再去检查数据是否完成。

通过并发循环可以提供性能，利用多核，解决CPU热点。正因为协程可以大量创建，才能在循环体中如此使用，如果是使用线程的话，就需要引入线程池之类的东西，防止创建过多线程，而协程则简单的多。

Chain Filter技术

前面提到了Future技术首尾相连，可以形成一个并发的pipe filter。这种方式可以做很多事情，如果每个Filter都由同一个函数组成，还可以有一种简单的办法把他们连起来。

// A concurrent prime sieve
 
 package main
 
 // Send the sequence 2,3,4,... to channel 'ch'.
 func Generate(ch chan<- int) {
 	for i := 2; ; i++ {
 		ch <- i // Send 'i' to channel 'ch'.
 	}
 }
 
 // Copy the values from channel 'in' to channel 'out',// removing those divisible by 'prime'.
 func Filter(in <-chan int,out chan<- int,prime int) {
 	for {
 		i := <-in // Receive value from 'in'.
 		if i%prime != 0 {
 			out <- i // Send 'i' to 'out'.
 		}
 	}
 }
 
 // The prime sieve: Daisy-chain Filter processes.
 func main() {
 	ch := make(chan int) // Create a new channel.
 	go Generate(ch)      // Launch Generate goroutine.
 	for i := 0; i < 10; i++ {
 		prime := <-ch
 		print(prime,"\n")
 		ch1 := make(chan int)
 		go Filter(ch,ch1,prime)
 		ch = ch1
 	}
 }

Chain-Filter通过简单的代码创建并发的过滤器链。这种办法还有一个好处，就是每个通道只有两个协程会访问，就不会有激烈的竞争，性能会比较好。

共享变量

协程之间的通信只能够通过通道。但是我们习惯于共享变量，而且很多时候使用共享变量能让代码更简洁。比如一个Server有两个状态开和关。其他仅仅希望获取或改变其状态，那又该如何做呢。可以将这个变量至于0通道中，并使用一个协程来维护。

//共享变量有一个读通道和一个写通道组成
 type sharded_var struct {
 	reader chan int
 	writer chan int
 }
 
 //共享变量维护协程
 func sharded_var_whachdog(v sharded_var) {
 	go func() {
 		//初始值
 		var value int = 0
 		for {
 			//监听读写通道，完成服务
 			select {
 			case value = <-v.writer:
 			case v.reader <- value:
 			}
 		}
 	}()
 }
 
 func main() {
 	//初始化，并开始维护协程
 	v := sharded_var{make(chan int),make(chan int)}
 	sharded_var_whachdog(v)
 
 	//读取初始值
 	fmt.Println(<-v.reader)
 	//写入一个值
 	v.writer <- 1
 	//读取新写入的值
 	fmt.Println(<-v.reader)
 }

一般来说，协程之间不推荐使用共享变量来交互，但是按照这个办法，在一些场合，使用共享变量也是可取的。很多平台上有较为原生的共享变量支持，到底用那种实现比较好，就见仁见智了。另外利用协程和通道，可以还实现各种常见的并发数据结构，如锁等等，就不一一赘述。

协程泄漏

协程和内存一样，是系统的资源。对于内存，有自动垃圾回收。但是对于协程，没有相应的回收机制。会不会若干年后，协程普及了，协程泄漏和内存泄漏一样成为程序员永远的痛呢？一般而言，协程执行结束后就会销毁。协程也会占用内存，如果发生协程泄漏，影响和内存泄漏一样严重。轻则拖慢程序，重则压垮机器。

C和C++都是没有自动内存回收的程序设计语言，但只要有良好的编程习惯，就能解决规避问题。对于协程是一样的，只要有好习惯就可以了。

只有两种情况会导致协程无法结束。一种情况是协程想从一个通道读数据，但无人往这个通道写入数据，或许这个通道已经被遗忘了。还有一种情况是程想往一个通道写数据，可是由于无人监听这个通道，该协程将永远无法向下执行。下面分别讨论如何避免这两种情况。

对于协程想从一个通道读数据，但无人往这个通道写入数据这种情况。解决的办法很简单，加入超时机制。对于有不确定会不会返回的情况，必须加入超时，避免出现永久等待。另外不一定要使用定时器才能终止协程。也可以对外暴露一个退出提醒通道。任何其他协程都可以通过该通道来提醒这个协程终止。

func never_leak(ch chan int) {
 	//初始化timeout，缓冲为1
 	timeout := make(chan bool,1)
 	//启动timeout协程，由于缓存为1，不可能泄露
 	go func() {
 		time.Sleep(1 * time.Second)
 		timeout <- true
 	}()
 	//监听通道，由于设有超时，不可能泄露
 	select {
 	case <-ch:
 		// a read from ch has occurred
 	case <-timeout:
 		// the read from ch has timed out
 	}
 }

和内存里面的对象一样，对于长期存在的协程，我们不用担心泄漏问题。一是长期存在，二是数量较少。要警惕的只有那些被临时创建的协程，这些协程数量大且生命周期短，往往是在循环中创建的，要应用前面提到的办法，避免泄漏发生。协程也是把双刃剑，如果出问题，不但没能提高程序性能，反而会让程序崩溃。但就像内存一样，同样有泄漏的风险，但越用越溜了。

并发模式之实现

在并发编程大行其道的今天，对协程和通道的支持成为各个平台比不可少的一部分。虽然各家有各家的叫法，但都能满足协程的基本要求—并发执行和可大量创建。笔者对他们的实现方式总结了一下。

下面列举一些已经支持协程的常见的语言和平台。

--------------------------------------------我是分割线----------------------------------------------------