// one project main.go
package main

import (
	"fmt"
	"runtime"
	"sync"
)

var counter int = 0

func Count(lock *sync.Mutex) {

	//每次对counter操作前都需要加锁，每次使用完之后都要解锁。
	lock.Lock()
	counter++
	fmt.Println(counter)
	lock.Unlock()
}

func main() {
	//创建一个sync包下的Mutex结构体
	lock := &sync.Mutex{}

	for i := 0; i < 10; i++ {
		go Count(lock)
	}

	for {
		lock.Lock()

		c := counter

		lock.Unlock()

		runtime.Gosched()
		if c > 0 {
			break
		}
	}
}

不要通过共享内存来通信，而应该通过通信来共享内存。

使用channel来实现刚刚那个例子

package main

import "fmt"

func Count(ch chan int) {
	fmt.Println("Counting")
	ch <- 1
}

func main() {
	chs := make([]chan int,10)
	for i := 0; i < 10; i++ {
		chs[i] = make(chan int)
		go Count(chs[i])
	}

	for _,ch := range chs {
		<-ch
	}
}

// one project main.go
package main

import (
	"fmt"
)

func main() {
	//channel声明
	// var chanName chan elementType
	var ch chan int
	//一个map键为stringkey为bool类型的channel
	//var m map[string]chan bool
	//使用make定义一个channel
	//ch1 := make(chan int)
	/*
		将一个数据写入（发送）带channel
		ch <- value
		将一个数据从channel中读出
		value := <- value
	*/

	//select语句

	select {
	//如果chan1成功读到数据，则进行该case处理语句
	case <-chan1:
	//如果成功向chan2写入数据，则进行该case处理语句
	case chan2 <- 1:
	//如果上面都没有成功，则进入default处理流程
	default:

	}

	ch2 := make(chan int)
	for {
		select {
		case ch <- 0:
		case ch <- 1:
		}
		i := <-ch2
		fmt.Println("value",i)
	}

	//缓冲机制
	//创建一个带缓冲的channel
	c := make(chan int,1024)
	//使用for range读取
	for i := range c {
		fmt.Println(i)
	}
}