Go---Go并发编程（详细）（二）

ch <- 10 // 把10发送到ch中   

x := <- ch // 从ch中接收值并赋值给变量x
<-ch       // 从ch中接收值，忽略结果   

close(ch)   

func main() {
   ch1 := make(chan int)
   ch1 <- 10           // deadlock!
}

func main() {
    ch := make(chan int)
    go func(ch1 chan int) {
        res := <- ch1
        fmt.Println(res)
    }(ch)
    ch <- 10
    close(ch)
    time.Sleep(time.Second)     // 延缓结束时间使 goroutine 能够执行完
}

func main() {
   ch1 := make(chan int,10)
   ch1 <- 10           // 不会报 deadlock!
   for i := 0; i < 10; i++ {
      ch1 <- i
      fmt.Println(i+1)         // 超出缓存范围会报 deadlock!
   }
}

func counter(out chan<- int) {
    for i := 0; i < 100; i++ {
        out <- i
    }
    close(out)
}
func squarer(out chan<- int, in <-chan int) {
    for i := range in {
        out <- i * i
    }
    close(out)
}
func printer(in <-chan int) {
    for i := range in {
        fmt.Println(i)
    }
}
func main() {
    ch1 := make(chan int)
    ch2 := make(chan int)
    go counter(ch1)
    go squarer(ch2, ch1)
    printer(ch2)
}  

package main
import (
   "fmt"
   "time"
)
func main() {
   // timer 简单使用
   timer := time.NewTimer(2 * time.Second)
   t1 := time.Now()
   fmt.Println(t1)
   t2 := <- timer.C   // 当打印完 t1 会停留2秒钟
   fmt.Println(t2)
   //t3 := <- timer.C // 再次接收会 deadlock!
   //fmt.Println(t3)
}

package main
import (
   "fmt"
   "time"
)
func main() {
   //实现延时功能
   // 1.time.Sleep()
   time.Sleep(2 * time.Second)
   fmt.Println(time.Now())
   // 2.<- time.NewTimer().C
   <- time.NewTimer(2 * time.Second).C
   fmt.Println(time.Now())
   // 3.<- time.After()
   <- time.After(2 * time.Second)
   fmt.Println(time.Now())
}

package main
import (
   "fmt"
   "time"
)
func main() {
   timer := time.NewTimer(2 * time.Second)
   go func() {
      fmt.Println("定时器准备工作")
      // 如果将定时器停止则，协程也在这一步终止，不会继续执行该协程后续代码，但不会影响别的协程进行
      <- timer.C                   
      fmt.Println("定时器开始工作")
   }()
   go func() {
      fmt.Println("另一个协程正在运行")
   }()
   stop := timer.Stop()
   if stop {
      fmt.Println("停止计时器成功")
   }
   time.Sleep(5 * time.Second)
}

package main
import (
   "fmt"
   "time"
)
func main() {
   timer := time.NewTimer(3 * time.Second)
   // 将定时器时间改为 1 秒
   timer.Reset(1 * time.Second)
   fmt.Println(time.Now())
   // 一秒后执行
   fmt.Println(<-timer.C)
   timer.Reset(2 * time.Second)
   // 重置后的 timer 可以再次使用，不会出现 deadlock!
   fmt.Println(<-timer.C)
}

package main
import (
   "fmt"
   "time"
)
func main() {
   ticker := time.NewTicker(time.Second)
   go func() {
      i := 0
      for i != 5 {
         i ++
         fmt.Println(<- ticker.C)
      }
      fmt.Println("协程结束")
   }()
   time.Sleep(6 * time.Second)
}

for{
    // 尝试从ch1接收值
    data, ok := <-ch1
    // 尝试从ch2接收值
    data, ok := <-ch2
    …
}

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

package main
import (
   "fmt"
)
func main() {
   // 定义两个没有缓存的通道
   ch1 := make(chan string)
   ch2 := make(chan string)
   // 执行两个子协程来向通道发送数据
   go func(chan string) {
      ch1 <- "ch1"
   }(ch1)
   go func(chan string) {
      ch2 <- "ch2"
   }(ch2)
   // 使用select对管道进行监控，只会执行第一个被发送数据的通道
   select {
   case s1 := <- ch1:
      fmt.Println("s1 =",s1)
   case s2 := <- ch2:
      fmt.Println("s2 =",s2)
   }
}

package main
import (
   "fmt"
   "time"
)
func main() {
   // 创建通道
   ch := make(chan string,10)
   // 子协程发送数据
   go func(ch1 chan string) {
      for {
         select {
         case ch1 <- "hello":
            fmt.Println("发送数据")
         default:
            fmt.Println("管道满了")
         }
         time.Sleep(time.Microsecond * 500000)
      }
   }(ch)
   // 接收数据
   for s := range  ch {
      fmt.Println("res:",s)
      time.Sleep(time.Second)
   }
}

package main
import (
   "fmt"
   "sync"
)
var x int64
var wg sync.WaitGroup
func add() {
   defer wg.Done()
   for i := 0; i < 5000; i++ {
      x++
   }
}
// 原本预期为10000，但是输出却是不确定的
func main() {
   wg.Add(2)
   go add()
   go add()
   wg.Wait()
   fmt.Println(x)
}

package main
import (
   "fmt"
   "sync"
)
var x int64
var wg sync.WaitGroup
var lock sync.Mutex
func add() {
   for i := 0; i < 5000; i++ {
      lock.Lock() // 加锁
      x ++
      lock.Unlock() // 解锁
   }
   wg.Done()
}
// 结果与预期一致
func main() {
   wg.Add(2)
   go add()
   go add()
   wg.Wait()
   fmt.Println(x)
}