// 在主線程（可以理解成進(jìn)程）中，開啟一個goroutine，該協(xié)程每秒輸出 “hello，world”
// 在主線程中也每隔一秒輸出“hello,golang”,輸出10次后，退出程序
// 要求主線程和goroutine同時執(zhí)行
//編寫一個函數(shù)，每隔1秒輸出 “hello，world”
func test(){
   for i := 1;i<=10;i++{
		fmt.Println("test() hello,world"+strconv.Itoa(i))
		time.Sleep(time.Second)
	}
}
func main(){
    go test() // 開啟了一個協(xié)程
    for i:=1;i<=10;i++{
		fmt.Println(" main() hello,golang"+strconv.Itoa(i))
		time.Sleep(time.Second)
	}
}

 package main
 import "fmt"
 import "runtime"
func main(){
	// 獲取當(dāng)前系統(tǒng)CPU的數(shù)量
	num := runtime.NumCPU()
	// 這里設(shè)置num-1的CPU運(yùn)行g(shù)o程序
	runtime.GOMAXPROCS(num)
	fmt.Println("num=",num)
}

package main
import (
	"fmt"
	"time"
	"sync"
)
// 需求：現(xiàn)在要計算 1-200的各個數(shù)的階乘，并且把各個數(shù)的階乘放入到map中
// 最后顯示出來。要求使用goroutine完成
// 思路
// 1. 編寫一個函數(shù)，來計算各個數(shù)的階乘，并放入到map中
// 2. 我們啟動的協(xié)程多個，統(tǒng)計的將結(jié)果放入到map中
// 3. map應(yīng)該做出一個全局的
var (
  myMap = make(map[int]int,10)
  // 聲明一個全局的互斥鎖
  // lock 是一個全局的互斥鎖
  //sync 是包：synchornized 同步
  // Mutex: 是互斥
  lock sync.Mutex
)
// test函數(shù)就是計算n！,讓將這個結(jié)果放入到myMap
func test(n int){
	res := 1
	for i := 1;i<=n;i++{
		res *= i
	}
	// 這里我們將res放入到myMap
	// 加鎖
	lock.Lock()
	myMap[n] = res  // concurrent map writes?
	// 解鎖
	lock.Unlock()
}
func main(){
	// 我們這里開啟多個協(xié)程完成這個任務(wù)[200個]
	for i := 1;i<=20;i++{
		go test(i)
	}
	// 休眠10秒鐘【第二個問題】
	time.Sleep(time.Second * 10)
	lock.Lock()
	// 這里我們輸出結(jié)果 變量這個結(jié)果
	for i,v := range myMap{
		fmt.Printf("map[%d]=%d\n",i,v)
	} 
	lock.Unlock()
}

package main
import (
	"fmt"
)
func main(){
	// 演示一下管道的使用
	// 1.創(chuàng)建一個可以存放3個int類型的管道
	var intChan chan int
	intChan = make(chan int,3)
	// 2.看看intChannel是什么
	fmt.Printf("intChan 的值=%v intChan本身的地址=%p\n",intChan,&intChan)
	// 3.向管道寫入數(shù)據(jù)
	intChan<- 10
	num := 211
	intChan<- num
	// 注意點(diǎn)，當(dāng)我們給管寫入數(shù)據(jù)時，不能超過其容量
	intChan<- 50
	// intChan<- 98
	//4. 看看管道的長度和cap(容量)
	fmt.Printf("channel len=%v cap=%v \n",len(intChan),cap(intChan)) // 2,3
	// 5.從管道中讀取數(shù)據(jù)
	var num2 int 
	num2 = <-intChan
	fmt.Println("num2=",num2)
	fmt.Printf("channel len=%v cap=%v \n",len(intChan),cap(intChan)) // 2,3
	// 6.在沒有使用協(xié)程的情況下，如果我們的管道數(shù)據(jù)已經(jīng)全部取出，再取就會報告 deadlock
	num3 := <-intChan
	num4 := <-intChan
	// num5 := <-intChan
	fmt.Println("num3=",num3,"num4=",num4)//,"num5=",num5)
}

package main
import (
	"fmt"
)
type Cat struct{
	Name string
	Age int
}
func main(){
	// 定義一個存放任意數(shù)據(jù)類型的管道  3個數(shù)據(jù)
	// var callChan chan interface{}
	allChan := make(chan interface{},3)
	allChan<- 10
	allChan<- "tom jack"
	cat := Cat{"小花貓",4}
	allChan<- cat
	// 我們希望獲得到管道中的第三個元素，則先將前2個推出
	<-allChan
	<-allChan
	newCat := <-allChan // 從管道中取出的Cat是什么？
	fmt.Printf("newCat=%T,newCat=%v\n",newCat,newCat)
	// 下面的寫法是錯誤的！編譯不通過
	// fmt.Printf("newCat.Name=%v",newCat.Name)
	// 使用類型斷言
	a := newCat.(Cat)
	fmt.Printf("newCat.Name=%v",a.Name)
}

package main
import (
	"fmt"
)
func main(){
	intChan := make(chan int,3)
	intChan<- 100
	intChan<- 200
	close(intChan) // close
	// 這是不能夠再寫入到channel
	// intChan<-300
	fmt.Println("okook~")
	// 當(dāng)管道關(guān)閉后，讀取數(shù)據(jù)是可以的
	n1 := <-intChan
	fmt.Println("n1=",n1)
	// 遍歷管道
	intChan2 := make(chan int,100)
	for i := 0; i< 100;i++{
		intChan2<-i*2 // 放入100個數(shù)據(jù)到管道
	}
	// 遍歷管道不能使用普通的for循環(huán)
	// 在遍歷時，如果channel沒有關(guān)閉，則會出現(xiàn)deadlock的錯誤
	// 在遍歷時，如果channel已經(jīng)關(guān)閉，則會正常遍歷數(shù)據(jù)，遍歷完后，就會退出遍歷
	close(intChan2)
	for  v := range intChan2{
		fmt.Println("v=",v)
	}
}