我就廢話不多說了，大家還是直接看代碼吧~

package main
import "fmt"
import "sync"
var ch = make(chan int)
func do(lock *sync.Mutex, ct *int) {
 lock.Lock()
 *ct++
 lock.Unlock()
 ch - 1
}
func main() {
 fmt.Println("hello thread")
 var ct = 0
 lock := sync.Mutex{}
 for i:=0; i10; i++ {
  go do(lock, ct)
 }
 for i:=0; i10; i++ {
  - ch
 }
 fmt.Println("ct=", ct)
}

輸出: 10

補充：Goroutine協(xié)程之間的數(shù)據(jù)溝通的方式

一個服務器物理線程能夠跑多個goroutine，成千上萬個goroutine 實際上跑在物理線程上的也就幾十個，但是java和c++創(chuàng)建成千上萬個線程會使得系統(tǒng)反應更慢，這是為什么goroutine能很快的原因。

那么goroutine協(xié)程之間是如何進行通信的呢？有兩種方式，

第一使用全局變量和鎖同步：讀寫鎖或互斥鎖對全局變量進行加鎖，實現(xiàn)多個goroute的數(shù)據(jù)共享。

第二：Channel 管道進行數(shù)據(jù)同步

1.加鎖操作

互斥鎖就是將公共資源進行加鎖操作，以便于goroute對數(shù)據(jù)進行更改。

package main 
import (
 "fmt"
 lock "sync"
 "time"
)
 
type task struct {
 n int
}
 
//通過全局的 map 來通訊
var (
 sum 
)
 
func calc(t *task) {
 var sum uint64
 sum = 1
 for i := 1; i  t.n; i++ {
 sum *= uint64(i)
 }
 fmt.Printf("%d! = %v\n", t.n, sum)
 lock.Lock()
 sum++
 lock.Unlock() 
}
 
func main() {
 for i := 0; i  100; i++ {
 var t *task = task{n: i}
 go calc(t)
 }
 
 time.Sleep(5 * time.Second) 
 lock.Lock()
 // for k, v := range m {
 // fmt.Printf("%d! = %v\n", k, v)
 // }
 lock.Unlock()
}

2.channel管道通信

單純地將函數(shù)并發(fā)執(zhí)行是沒有意義的。函數(shù)與函數(shù)間需要交換數(shù)據(jù)才能體現(xiàn)并發(fā)執(zhí)行函數(shù)的意義。雖然可以使用共享內存進行數(shù)據(jù)交換，但是共享內存在不同的 goroutine 中容易發(fā)生競態(tài)問題。為了保證數(shù)據(jù)交換的正確性，必須使用互斥量對內存進行加鎖，這種做法勢必造成性能問題。

Go 語言提倡使用通信的方法代替共享內存，這里通信的方法就是使用通道（channel）

channel 具有幾個特性：

1.類似unix中的管道（pipe）

2.先進先出

3.線程安全，多個goroutine同時訪問，不需要加鎖

4.channel是有類型的，一個整數(shù)的channel 只能存放整

2.1使用通道發(fā)送數(shù)據(jù)

通道創(chuàng)建后，就可以使用通道進行發(fā)送和接收操作。

1) 通道發(fā)送數(shù)據(jù)的格式

通道的發(fā)送使用特殊的操作符-，將數(shù)據(jù)通過通道發(fā)送的格式為：

通道變量 - 值

通道變量：通過make創(chuàng)建好的通道實例。

值：可以是變量、常量、表達式或者函數(shù)返回值等。值的類型必須與ch通道的元素類型一致。

2) 通過通道發(fā)送數(shù)據(jù)的例子

使用 make 創(chuàng)建一個通道后，就可以使用-向通道發(fā)送數(shù)據(jù)，代碼如下：

// 創(chuàng)建一個空接口通道
ch := make(chan interface{})
// 將0放入通道中
ch - 0
// 將hello字符串放入通道中
ch - "hello"

2.2 使用通道接收數(shù)據(jù)

1)通道接收同樣使用-操作符，通道接收有如下特性：

① 通道的收發(fā)操作在不同的兩個 goroutine 間進行。

由于通道的數(shù)據(jù)在沒有接收方處理時，數(shù)據(jù)發(fā)送方會持續(xù)阻塞，因此通道的接收必定在另外一個 goroutine 中進行。

② 接收將持續(xù)阻塞直到發(fā)送方發(fā)送數(shù)據(jù)。

如果接收方接收時，通道中沒有發(fā)送方發(fā)送數(shù)據(jù)，接收方也會發(fā)生阻塞，直到發(fā)送方發(fā)送數(shù)據(jù)為止

③ 每次接收一個元素。

通道一次只能接收一個數(shù)據(jù)元素。

通道的數(shù)據(jù)接收一共有以下 4 種寫法。

2) 阻塞接收數(shù)據(jù)

阻塞模式接收數(shù)據(jù)時，將接收變量作為-操作符的左值，格式如下：

data := -ch

執(zhí)行該語句時將會阻塞，直到接收到數(shù)據(jù)并賦值給 data 變量。

3) 非阻塞接收數(shù)據(jù)

使用非阻塞方式從通道接收數(shù)據(jù)時，語句不會發(fā)生阻塞，格式如下：

data, ok := -ch

data：表示接收到的數(shù)據(jù)。未接收到數(shù)據(jù)時，data 為通道類型的零值。

ok：表示是否接收到數(shù)據(jù)。

非阻塞的通道接收方法可能造成高的 CPU 占用，因此使用非常少。如果需要實現(xiàn)接收超時檢測，可以配合 select 和計時器 channel 進行，可以參見后面的內容。

4) 接收任意數(shù)據(jù)，忽略接收的數(shù)據(jù)

阻塞接收數(shù)據(jù)后，忽略從通道返回的數(shù)據(jù)，格式如下：

-ch

執(zhí)行該語句時將會發(fā)生阻塞，直到接收到數(shù)據(jù)，但接收到的數(shù)據(jù)會被忽略。這個方式實際上只是通過通道在 goroutine 間阻塞收發(fā)實現(xiàn)并發(fā)

2.3 發(fā)生阻塞的2種情況

1）發(fā)送方發(fā)送阻塞：在通道數(shù)據(jù)沒有接收方處理時，通道的數(shù)據(jù)一開始會存放到固定的數(shù)據(jù)緩沖區(qū)內，超出緩沖區(qū)的大小將發(fā)生持續(xù)阻塞。

package main 
func main() {
 var ch chan int
 ch = make(chan int, 5) //定義數(shù)據(jù)緩存區(qū)設置為5個大小
 //將數(shù)據(jù)保存在緩沖區(qū)內并不會發(fā)生當前線程阻塞
 for i := 0; i  5; i++ {
 ch - i 
 } 
 //但將第6個加入通道（超出緩沖區(qū)）就會立即阻塞當前的協(xié)程（即main線程） 最后panic
 ch - 6 
}

這個程序的執(zhí)行結果直接painc 因為在管道加入ch - 6 的時候因為緩存區(qū)沒有那么大，并且沒有接收方去消化數(shù)據(jù)，故painc。

2） 數(shù)據(jù)接收方發(fā)生阻塞：如果接收方?jīng)]有接收到數(shù)據(jù)，接收方等待發(fā)送方發(fā)送數(shù)據(jù)，等待的過程也會使數(shù)據(jù)接收的協(xié)程發(fā)生阻塞。

package main 
import (
 "fmt"
 "time"
)
 
func main() { 
 var ch chan int
 ch = make(chan int) //無定義數(shù)據(jù)緩存區(qū)
 
 go func() { 
 var a = -ch //執(zhí)行第一次取出
 fmt.Println(a) 
 }() 
 time.Sleep(time.Second * 4) //主線程等待4才給管道數(shù)據(jù) 
 ch - 1 //通道里只入一個數(shù)據(jù)
 
 //接收方協(xié)程是一個并發(fā)匿名函數(shù) 
 time.Sleep(time.Second * 5) //主線程等待5秒讓goroute有處理時間然后結束
 }

這個程序的執(zhí)行結果是延時4秒后控制臺打印出通道的值1，5秒后主程序結束。上邊的程序是先讓接收者協(xié)程開啟等待接收通道的值，而發(fā)送者是主函數(shù)延遲4秒后才將值放入通道ch,匿名函數(shù)中不得不等待發(fā)送者的值，所以造成了匿名并發(fā)函數(shù)的阻塞。 我們可以思考到，如果去掉4秒等待的時間， 這個程序就是使用channel作為協(xié)程之間同步的最簡單的例子，我們發(fā)現(xiàn)channel同步的特性就是無數(shù)據(jù)緩存區(qū)。

同樣一個程序，當你把接受者 go func() 程序放到 ch-1 的下邊，就會painc。 為什么？ 以為ch通道并沒有緩存區(qū)，并且接受者還未執(zhí)行。導致painc。

package main 
import (
 "fmt"
 "time"
)
 
func main() { 
 var ch chan int
 ch = make(chan int) //無定義數(shù)據(jù)緩存區(qū)
 
 //time.Sleep(time.Second * 4) //主線程等待4才給管道數(shù)據(jù)
 
 ch - 1 //通道里只入一個數(shù)據(jù)
 
 //接收方協(xié)程是一個并發(fā)匿名函數(shù)
 //一個并發(fā)執(zhí)行的協(xié)程
 go func() {
 
 var a = -ch //執(zhí)行第一次取出
 fmt.Println(a) 
 }()
 time.Sleep(time.Second * 5) //主線程等待5秒讓goroute有處理時間然后結束
}

以上為個人經(jīng)驗，希望能給大家一個參考，也希望大家多多支持腳本之家。如有錯誤或未考慮完全的地方，望不吝賜教。