go并发编程基础

var wg sync.WaitGroup
	wg.Add(2)
	c :=make(chan)
	go func() {
		say("world")
		wg.Done()
	}()
	go func() {
		say("hello")
		wg.Done()
	}()
	wg.Wait()
func say(s string) {
	for i := 0; i < 5; i++ {
		fmt.Println(s)
		time.Sleep(time.Millisecond * 500)

	}
}

go 关键子可以开起子进程goroutine进行并发编程，WaitGroup相当于计数器，一共开起几个goroutine,当所有goroutine执行完毕之后，主线程结束

 这样所有的子进程可同时进行

在go语言中，channel就是不同goroutine之间交流的途径，c :=mack(chan string)，往channel里发送一条消息或者从channel收听一条消息都会阻塞代码的运行，可以用select分别接收不同的channel

c1 := make(chan string)
	c2 := make(chan string)
	go func() {
		for {
			c1 <- "world"
			time.Sleep(time.Millisecond * 500)
		}
	}()
	go func() {
		for {
			c1 <- "hello"
			time.Sleep(time.Millisecond * 2000)
		}
	}()
for {
		select {
		case msg := <-c1:
			fmt.Println(msg)
		case msg := <-c2:
			fmt.Println(msg)
		}
	}

搜索文件实例

var query = "test"
var matches int
var workerCount = 0
var maxWorkerCount = 32
var searchRequest = make(chan string)
var workerDone = make(chan bool)
var foundMatch = make(chan bool)

func main() {
	start := time.Now()
	workerCount = 1
	go search("/data/v_godongvyu/", true)
	waitForWorkers()
	fmt.Println(matches, "matches")
	fm}
func waitForWorkers() {
	for {
		select {
		case path := <-searchRequest:
			workerCount++
			go search(path, true)
		case <-workerDone:
			workerCount--
			if workerCount == 0 {
				return
			}
		case <-foundMatch:
			matches++
		}
	}
}
func search(path string, master bool) {
	files, err := ioutil.ReadDir(path)
	if err == nil {
		for _, file := range files {
			name := file.Name()
			if name == query {
				foundMatch <- true
			}
			if file.IsDir() {
				if workerCount < maxWorkerCount {
					searchRequest <- path + name + "/"
				} else {
					search(path+name+"/", false)
				}
			}
		}
		if master {
			workerDone <- true
		}
	}
}t.Println(time.Since(start))