go设计模式_并行模式

2018-02-23

并行（Parallelism）:完成大量的独立任务；

有界并行模式 (Bounded Parallelism Pattern):完成大量资源限制的独立任务；

并行模式

package parallelism

import (
	"crypto/md5"
	"errors"
	"fmt"
	"io/ioutil"
	"os"
	"path/filepath"
	"sort"
	"sync"
)

// A result is the product of reading and summing a file using MD5.
// 结果是使用MD5读取和总结文件的结果。
type result struct {
	path string
	sum  [md5.Size]byte
	err  error
}

// sumFiles starts goroutines to walk the directory tree at root and digest each
// regular file.  These goroutines send the results of the digests on the result
// channel and send the result of the walk on the error channel.  If done is
// closed, sumFiles abandons its work.
// sumfiles开始Goroutines走目录树的根和消化每个正规文件。
// 这些概念将消化结果结果信道和发送对误差通道走的结果。
// 如果做的是封闭的，sumfiles放弃工作。
func sumFiles(done <-chan struct{}, root string) (<-chan result, <-chan error) {
	// For each regular file, start a goroutine that sums the file and sends
    // the result on c.  Send the result of the walk on errc.
    // 每个规则的文件，启动一个goroutine里总结文件和发送C.发送对ERRC走的结果。
	c := make(chan result)
	errc := make(chan error, 1)
	go func() { // HL
		var wg sync.WaitGroup
		err := filepath.Walk(root, func(path string, info os.FileInfo, err error) error {
			if err != nil {
				return err
			}
			if !info.Mode().IsRegular() {
				return nil
			}
			wg.Add(1)
			go func() { // HL
				data, err := ioutil.ReadFile(path)
				select {
				case c <- result{path, md5.Sum(data), err}: // HL
				case <-done: // HL
				}
				wg.Done()
			}()
            // Abort the walk if done is closed.
            // 如果关闭的话，中止行走。
			select {
			case <-done: // HL
				return errors.New("walk canceled")
			default:
				return nil
			}
		})
		// Walk has returned, so all calls to wg.Add are done.  Start a
        // goroutine to close c once all the sends are done.
        // 步行回来了，所以所有对WG的调用都完成了。一旦所有的发送完成，就开始关闭C。
		go func() { // HL
			wg.Wait()
			close(c) // HL
		}()
		// No select needed here, since errc is buffered.
		errc <- err // HL
	}()
	return c, errc
}

// MD5All reads all the files in the file tree rooted at root and returns a map
// from file path to the MD5 sum of the file's contents.  If the directory walk
// fails or any read operation fails, MD5All returns an error.  In that case,
// MD5All does not wait for inflight read operations to complete.
// md5all读入文件树的根的所有文件并返回文件路径映射到文件内容的校验和。
// 如果目录走失败或任何读操作失败，md5all返回一个错误。
// 在这种情况下，md5all不等待机上读取操作完成。
func MD5All(root string) (map[string][md5.Size]byte, error) {
	// MD5All closes the done channel when it returns; it may do so before
    // receiving all the values from c and errc.
    // md5all关闭了通道，它返回时；可以在C和ERRC接收所有的值。
	done := make(chan struct{}) // HLdone
	defer close(done)           // HLdone

	c, errc := sumFiles(done, root) // HLdone

	m := make(map[string][md5.Size]byte)
	for r := range c { // HLrange
		if r.err != nil {
			return nil, r.err
		}
		m[r.path] = r.sum
	}
	if err := <-errc; err != nil {
		return nil, err
	}
	return m, nil
}

func main() {
	// Calculate the MD5 sum of all files under the specified directory,
    // then print the results sorted by path name.
    // 计算指定目录下所有文件的MD5和，然后打印按路径名称排序的结果。
	m, err := MD5All(os.Args[1])
	if err != nil {
		fmt.Println(err)
		return
	}
	var paths []string
	for path := range m {
		paths = append(paths, path)
	}
	sort.Strings(paths)
	for _, path := range paths {
		fmt.Printf("%x  %s\n", m[path], path)
	}
}

有界并行模式

package bounded_parallelism

import (
	"crypto/md5"
	"errors"
	"fmt"
	"io/ioutil"
	"os"
	"path/filepath"
	"sort"
	"sync"
)

// walkFiles starts a goroutine to walk the directory tree at root and send the
// path of each regular file on the string channel.  It sends the result of the
// walk on the error channel.  If done is closed, walkFiles abandons its work.
// walkfiles开始一个goroutine里行走的目录树在根和发送每个规则文件的路径的字符串通道。
// 它把错误的结果发送到错误通道。如果做的是封闭的，walkfiles放弃工作。
func walkFiles(done <-chan struct{}, root string) (<-chan string, <-chan error) {
	paths := make(chan string)
	errc := make(chan error, 1)
	go func() { // HL
        // Close the paths channel after Walk returns.
        // 返回后关闭路径通道。
		defer close(paths) // HL
        // No select needed for this send, since errc is buffered.
        // 没有选择需要发送，由于ERRC缓冲。
		errc <- filepath.Walk(root, func(path string, info os.FileInfo, err error) error { // HL
			if err != nil {
				return err
			}
			if !info.Mode().IsRegular() {
				return nil
			}
			select {
			case paths <- path: // HL
			case <-done: // HL
				return errors.New("walk canceled")
			}
			return nil
		})
	}()
	return paths, errc
}

// A result is the product of reading and summing a file using MD5.
// 结果是使用MD5读取和总结文件的结果。
type result struct {
	path string
	sum  [md5.Size]byte
	err  error
}

// digester reads path names from paths and sends digests of the corresponding
// files on c until either paths or done is closed.
// 消化器从路径中读取路径名，并在C上发送相应的文件摘要，直到路径或操作结束为止。
func digester(done <-chan struct{}, paths <-chan string, c chan<- result) {
	for path := range paths { // HLpaths
		data, err := ioutil.ReadFile(path)
		select {
		case c <- result{path, md5.Sum(data), err}:
		case <-done:
			return
		}
	}
}

// MD5All reads all the files in the file tree rooted at root and returns a map
// from file path to the MD5 sum of the file's contents.  If the directory walk
// fails or any read operation fails, MD5All returns an error.  In that case,
// MD5All does not wait for inflight read operations to complete.
// md5all读入文件树的根的所有文件并返回文件路径映射到文件内容的校验和。
// 如果目录走失败或任何读操作失败，md5all返回一个错误。
// 在这种情况下，md5all不等待机上读取操作完成。
func MD5All(root string) (map[string][md5.Size]byte, error) {
	// MD5All closes the done channel when it returns; it may do so before
    // receiving all the values from c and errc.
    // md5all关闭了通道，它返回时；可以在C和ERRC接收所有的值。
	done := make(chan struct{})
	defer close(done)

	paths, errc := walkFiles(done, root)

    // Start a fixed number of goroutines to read and digest files.
    // 开始一个固定数量的概念阅读文件。
	c := make(chan result) // HLc
	var wg sync.WaitGroup
	const numDigesters = 20
	wg.Add(numDigesters)
	for i := 0; i < numDigesters; i++ {
		go func() {
			digester(done, paths, c) // HLc
			wg.Done()
		}()
	}
	go func() {
		wg.Wait()
		close(c) // HLc
	}()
	// End of pipeline. OMIT
    // 管道末端。省略
	m := make(map[string][md5.Size]byte)
	for r := range c {
		if r.err != nil {
			return nil, r.err
		}
		m[r.path] = r.sum
	}
    // Check whether the Walk failed.
    // 检查是否走失败。
	if err := <-errc; err != nil { // HLerrc
		return nil, err
	}
	return m, nil
}

func main() {
	// Calculate the MD5 sum of all files under the specified directory,
    // then print the results sorted by path name.
    // 计算指定目录下所有文件的MD5和，然后打印按路径名称排序的结果。
	m, err := MD5All(os.Args[1])
	if err != nil {
		fmt.Println(err)
		return
	}
	var paths []string
	for path := range m {
		paths = append(paths, path)
	}
	sort.Strings(paths)
	for _, path := range paths {
		fmt.Printf("%x  %s\n", m[path], path)
	}
}