Go语言圣经 - 第8章 Goroutines 和 Channels - 8.5 并发的循环

第8章 Goroutines 和 Channels

Go语言中的并发程序可以用两种手段来实现：goroutine 和 channel，其支持顺序通信进程，或被简称为CSP，CSP是一种并发编程模型，在这种并发编程模型中，值会在不同运行实例中传递，第二个手段便是多线程共享内存

8.5 并发的循环

本节我们来看看在并行时循环迭代的常见并发模型，我们把全尺寸图片生成一些缩略图，下面这个函数能帮我们拉伸图片，我们直接用就行了

package thumbnail

func ImageFile(infile string) (string error)

现在我们来构建这个函数，就叫他makeThumbnais 吧

func makeThumbnails(filenames []string) (string, error) {
	for _, f := range filenames {
		if _, err := thumbnail.ImageFile(f); err != nil {
			log.Println(err)
		}
	}
}

上面每一个file都是独立的，我们再使用go 关键字把每次处理放入goroutine中，注意下面我们并没有处理错误

func makeThumbnails(filenames []string) (string, error) {
	for _, f := range filenames {
		go thumbnail.ImageFile(f)
	}
}

这样所有上述的file就是并行的了，并且其中一个goroutine先完成时，makeThumnails就会返回，不管其他goroutine有没有结束，我们现在使用channel的通信机制来让所有的goroutine执行结束

func makeThumbnails(filenames []string) (string, error) {
	for _, f := range filenames {
		ch := make(chan struct{}) //创建一个通道
		go func(f string) {       //把遍历到的作为goroutine的参数给里面的函数
			thumbnail.ImageFile(f)  //goroutine函数执行结束时给channel中发送一个信息（这里是结构体）
			ch <- struct{}{}
		}(f)
		for range filenames {
			<- ch                   //接收端在主函数结尾部分，这就可以保证所有goroutine结束，因为channel没有接收到值时，程                               序是不会停止的
		}
	}
}

在上面这个函数中我们在goroutine中调用了函数，是函数就会存在调用失败的情况，现在我们使用通道技术将可能的错误从goroutine中传递出来

func makeThumbnails(filenames []string) (string, error) {
	for _, f := range filenames {
		errors := make(chan error)
		go func(f string) {
			_, err := thumbnail.ImageFile(f)    //保留返回的错误
			errors <- err                       //把错误发送出去
		}(f)
	}
	for range filenames {
		if err := <- errors;err != nil {        //接收错误，如果有的话就返回
			return err
		}
	}
	return nil                                //如果没有的话就返回空值
}

现在我们可以将调用函数可能会发生的错误传递出来了，不过这个程序是有问题的，因为我们传递一个错误，并且这个channel的错误没有被接收（这里的赋值给新变量err不算接收），所以channel会被堵塞，后续即使goroutine还有错误，也无法将错误成功传递，我们现在来新建一个有缓存的channel，并且我们让函数不管处理成功与否都返回合适的信息

func makeThumbnails(filenames []string) (thumbfiles []string, err error) {

	type item struct { //先定义一个结构体，为了把返回值整合近一个变量里，结构体内部成员分别是两个返回值
		thumbfile string
		err       error
	}

	ch := make(chan item, len(filenames))    //定义一个有缓存的通道

	for _, f := range filenames {
		go func(f string) {
			var it item                     //定义一个结构体类型的变量，用来调用
			it.thumbfile, it.err = thumbnail.ImageFile(f)
			ch <- it
		}(f)
	}

	for range filenames {
		it := <- ch
		if it.err != nil {
			return nil,it.err
		}
		thumbfiles = append(thumbfiles,it.thumbfile)
	}
	return thumbfiles,nil
}

上面这个程序已经很完美了但是我们还是想改一改，我们希望获得文件数量，在这里我们对每一个goroutine计数，我们使用了一个新的类型sync.WaitGroup,且看代码

func makeThumbnails(filenames <-chan string) int64 {
	
	sizes := make(chan int64)
	var wg sync.WaitGroup
	
	for f := range filenames {
		wg.Add(1)
		go func(f string) {
			defer wg.Done()
			thumb, err := thumbnail.ImageFile(f)
			if err != nil {
				log.Println(err)
				return
			}
			info, _ := os.Stat(err)
			sizes <- info.Size()
		}(f)
	}

	go func() {
		wg.Wait()
		close(sizes)
	}()

	var total int64
	
	for sise := range sizes {
		total += size
	}
	
	return total
}

上面的程序代码结构是当我们使用并发循环，但又不知道迭代次数时很通常而且很地道的写法