残阳似血的博客

Go语言诞生已经两周年了。最近由于参加ECUG的缘故，我学习了一下Go语言的语法，就立刻被Go语言的特性所吸引。

Go语言一些背景就不介绍了，大家可以自行到Go主页进行查看（可能要准备梯子，和python.org一样悲催的命运）。Go的优点很多，最重要的特点之一是其第一个在语言层面对并发进行了支持。正如Go设计的主旨之一，就是现在的语言都没有对多核进行优化，对并发支持很不好。

Java，C#，Python这些语言对多线程编程有一样的模型。本文就生产者消费者问题对Java和Go进行对比。

生产者消费者模型大家应该很熟了，在操作系统的一些概念中经常提到，简单地说，就是生产者生产一些数据，然后放到buffer中，同时消费者从buffer中来取这些数据。这样就让生产消费变成了异步的两个过程。当buffer中没有数据时，消费者就进入等待过程；而当buffer中数据已满时，生产者则需要等待buffer中数据被取出后再写入。

Go语言中提出了channel的概念，它实际上就是一个管道，也可以理解为消息队列。Go线程（这里要注意，Go线程不同意一般的系统线程，而是类似于协程的概念，Go中称为goroutine）之间可以通过channel来进行通信，而channel本身是同步的。Go当中不鼓励通过加锁的方式来进行共享内存操作，而是鼓励通过管道通信来共享内存。我们来看具体的实现就明白了。

首先给出传统的Java中实现生产者消费者问题的代码。我们先写一个Mixin类，来进行对buffer中数据的取出和放入的操作。

public class Mixin {
	private int BUFFERSIZE = 0;
	private int[] Buffer;
	private int index = -1;
	
	public Mixin(int BufferSize) {
		this.BUFFERSIZE = BufferSize;
		this.Buffer = new int[this.BUFFERSIZE];
	}
	
	public synchronized void put(int item) {
		while(this.index >= this.BUFFERSIZE - 1) {
			try{
				wait();
			}
			catch(InterruptedException e) {
			}
		}
		this.Buffer[++this.index] = item;
		notifyAll();
	}
	
	public synchronized int get() {
		while(this.index < 0) {
			try{
				wait();
			}
			catch(InterruptedException e) { }
		}
		int result = this.Buffer[this.index--];
		notifyAll();
		return result;
	}
}

put和get操作都需要加上synchronized关键字来保证同步，代码很好理解就不讲了。接着，我们分别实现Producer和Consumer类，它们都继承了Thread类，并实现了run方法。

Producer类：

public class Producer extends Thread {
	private Mixin m = null;
	private int thisId;
	
	public Producer(Mixin m, int id) {
		this.m = m;
		this.thisId = id;
	}
	
	public synchronized void run() {
		for(int i=0; i<10; i++) {
			this.m.put(i);
			System.out.println("Producer " + this.thisId + " produces data: " + i);
			try {
				sleep(10);
			} catch (InterruptedException e) { }
		}
	}
}

Consumer类：

public class Consumer extends Thread {
	private Mixin m = null;
	private int thisId;
	
	public Consumer(Mixin m, int id) {
		this.m = m;
		this.thisId = id;
	}
	
	public synchronized void run() {
		for(int i=0; i<20; i++) {
			int item = this.m.get();
			System.out.println("Cosumer " + this.thisId + " get data: " + item);
			try {
				sleep(10);
			} catch (InterruptedException e) { }
		}
	}
}

Producer就是简单地把一些数放入buffer中。Java中通过wait方法来阻塞当前线程，而通过notifyAll来唤起所有阻塞的线程。最后我们写一个类来运行main函数，我们起了两个Producer线程和一个Cosumer线程。

public class ProducerConsumer {

	public static void main(String[] args) {
		Mixin m = new Mixin(6);
		Producer p1 = new Producer(m, 1);
		Producer p2 = new Producer(m, 2);
		Consumer c = new Consumer(m, 1);
		
		p1.start();
		p2.start();
		c.start();
	
	}

}

在Go中，这个问题变得异常简单。我们实现两个函数来分别表示Producer和Consumer，通过go关键字+函数名的方式，来启动goroutine。而由于channel的支持，我们可以在Producer和Consumer之间直接通过channel来进行通信。代码如下：

package main

import (
	"fmt"
	"time"
)

func Producer(id int, item chan int) {
	for i:=0; i<10; i++ {
		item <- i
		fmt.Printf("Producer %d produces data: %d\n", id, i)
		time.Sleep(10 * 1e6)
	}
}

func Consumer(id int, item chan int) {
	for i:=0; i<20; i++ {
		c_item := <-item
		fmt.Printf("Consumer %d get data: %d\n", id, c_item)
		time.Sleep(10 * 1e6)
	}
}

func main() {
	item := make(chan int, 6)
	go Producer(1, item)
	go Producer(2, item)
	go Consumer(1, item)
	
	time.Sleep(1 * 1e9)
}

channel的创建通过内建的make函数，第二个参数是channel通道的大小。通过item<-i，Producer把i放入item这个channel中，而Consumer通过<-item操作来从channel中取数据。当channel中的数据超过了其负荷值时，Producer这个goroutine就简单地阻塞，同样，当channel中没有数据时，Consumer也相应会阻塞。

可以看到，在语言级别上对并发的支持让Go中的多线程编程和异步编程变得很简单，也很易懂。