package main
import (
	"fmt"
)

func main() {

	//演示一下管道的使用
	//1. 創(chuàng)建一個可以存放3個int類型的管道
	var intChan chan int
	intChan = make(chan int, 3)

	//2. 看看intChan是什么
	fmt.Printf("intChan 的值=%v intChan本身的地址=%p\n", intChan, &intChan)


	//3. 向管道寫入數據
	intChan<- 10
	num := 211
	intChan<- num
	intChan<- 50
	// //如果從channel取出數據后，可以繼續(xù)放入
	<-intChan
	intChan<- 98//注意點, 當我們給管寫入數據時，不能超過其容量


	//4. 看看管道的長度和cap(容量)
	fmt.Printf("channel len= %v cap=%v \n", len(intChan), cap(intChan)) // 3, 3

	//5. 從管道中讀取數據

	var num2 int
	num2 = <-intChan 
	fmt.Println("num2=", num2)
	fmt.Printf("channel len= %v cap=%v \n", len(intChan), cap(intChan))  // 2, 3

	//6. 在沒有使用協程的情況下，如果我們的管道數據已經全部取出，再取就會報告 deadlock

	num3 := <-intChan
	num4 := <-intChan

	//num5 := <-intChan

	fmt.Println("num3=", num3, "num4=", num4/*, "num5=", num5*/)
}

fmt.Printf("intChan 的值=%v intChan本身的地址=%p\n", intChan, &intChan)

package main
import (
	"fmt"
)

type Cat struct {
	Name string
	Age int
}

func main() {

	//定義一個存放任意數據類型的管道 3個數據
	//var allChan 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)
}

data := <-ch

data, ok := <-ch

<-ch

package main

import (
    "fmt"
)

func main() {

    // 構建一個通道
    ch := make(chan int)

    // 開啟一個并發(fā)匿名函數
    go func() {

        fmt.Println("start goroutine")

        // 通過通道通知main的goroutine
        ch <- 0

        fmt.Println("exit goroutine")

    }()

    fmt.Println("wait goroutine")

    // 等待匿名goroutine
    <-ch

    fmt.Println("all done")

}

for data := range ch {
}

package main
import (
	"fmt"
)

func main() {

	intChan := make(chan int, 3)
	intChan<- 100
	intChan<- 200
	close(intChan) // close
	//這時不能夠再寫入數到channel
	//intChan<- 300
	fmt.Println("okook~")
	//當管道關閉后，讀取數據是可以的
	n1 := <-intChan
	fmt.Println("n1=", n1)


	//遍歷管道
	intChan2 := make(chan int, 100)
	for i := 0; i < 100; i++ {
		intChan2<- i * 2  //放入100個數據到管道
	}

	//遍歷管道不能使用普通的 for 循環(huán)
	// for i := 0; i < len(intChan2); i++ {

	// }
	//在遍歷時，如果channel沒有關閉，則會出現deadlock的錯誤
	//在遍歷時，如果channel已經關閉，則會正常遍歷數據，遍歷完后，就會退出遍歷
	close(intChan2)
	for v := range intChan2 { //沒有下標
		fmt.Println("v=", v)
	}
}

package main

import (
	"fmt"
)

//write Data
func writeData(intChan chan int) {
	for i := 1; i <= 50; i++ {
		//放入數據
		intChan <- i //
		fmt.Println("writeData ", i)
		//time.Sleep(time.Second)
	}
	close(intChan) //關閉
}

//read data
func readData(intChan chan int, exitChan chan bool) {

	for {
		v, ok := <-intChan
		if !ok {
			break
		}
		// time.Sleep(time.Second)
		fmt.Printf("readData 讀到數據=%v\n", v)
	}
	//readData 讀取完數據后，即任務完成
	exitChan <- true
	close(exitChan)

}

func main() {

	//創(chuàng)建兩個管道
	intChan := make(chan int, 10)
	exitChan := make(chan bool, 1)

	go writeData(intChan)
	go readData(intChan, exitChan)

	//time.Sleep(time.Second * 10)
	for {
		_, ok := <-exitChan
		if !ok {
			break
		}
	}

}

package main

import (
	"fmt"
	"time"
)

//向 intChan放入 1-8000個數
func putNum(intChan chan int) {

	for i := 1; i <= 80000; i++ {
		intChan <- i
	}

	//關閉intChan
	close(intChan)
}

// 從 intChan取出數據，并判斷是否為素數,如果是，就
// 	//放入到primeChan
func primeNum(intChan chan int, primeChan chan int, exitChan chan bool) {

	//使用for 循環(huán)
	// var num int
	var flag bool //
	for {
		//time.Sleep(time.Millisecond * 10)
		num, ok := <-intChan //intChan 取不到..

		if !ok {
			break
		}
		flag = true //假設是素數
		//判斷num是不是素數
		for i := 2; i < num; i++ {
			if num%i == 0 { //說明該num不是素數
				flag = false
				break
			}
		}

		if flag {
			//將這個數就放入到primeChan
			primeChan <- num
		}
	}

	fmt.Println("有一個primeNum 協程因為取不到數據，退出")
	//這里我們還不能關閉 primeChan
	//向 exitChan 寫入true
	exitChan <- true

}

func main() {

	intChan := make(chan int, 1000)
	primeChan := make(chan int, 20000) //放入結果
	//標識退出的管道
	exitChan := make(chan bool, 4) // 4個

	start := time.Now().Unix()

	//開啟一個協程，向 intChan放入 1-8000個數
	go putNum(intChan)
	//開啟4個協程，從 intChan取出數據，并判斷是否為素數,如果是，就
	//放入到primeChan
	for i := 0; i < 4; i++ {
		go primeNum(intChan, primeChan, exitChan)
	}

	//這里我們主線程，進行處理
	//直接
	go func() {
		for i := 0; i < 4; i++ {
			<-exitChan
		}

		end := time.Now().Unix()
		fmt.Println("使用協程耗時=", end-start)

		//當我們從exitChan 取出了4個結果，就可以放心的關閉 prprimeChan
		close(primeChan)
	}()

	//遍歷我們的 primeChan ,把結果取出
	for {
		res, ok := <-primeChan
		if !ok {
			break
		}
		//將結果輸出
		fmt.Printf("素數=%d\n", res)
	}

	fmt.Println("main線程退出")

}

go func() {
		for i := 0; i < 4; i++ {
			<-exitChan
		}

		end := time.Now().Unix()
		fmt.Println("使用協程耗時=", end-start)

		//當我們從exitChan 取出了4個結果，就可以放心的關閉 prprimeChan
		close(primeChan)
	}()