golang学习笔记[3] 并发编程

// 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
}
}
}

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)
}
}