「Golang成長之路」併發任務的控制

併發任務的控制

在前面的內容中我們瞭解到了goroutine、channel和go常見的併發模式，這本文中我們來講解一下Go語言併發任務的控制

非阻塞等待
非阻塞等待經常用來判斷哪一個channel資料傳輸更快，我們使用select來判斷channel是否為阻塞狀態，如果阻塞則返回空串，和false，如果費阻塞則返回從channel裡拿到的值和true：
//非阻塞等待
func nonBlockWait(c chan string) (string, bool){
select{
case m := <- c:
   return m,true
default:
   return "", false
 }
}
呼叫：
func main() {
m1 := msgGen("service1")
m2 := msgGen("sercive2")
for{
   fmt.Println(<-m1)
   if m, ok := nonBlockWait(m2); ok{
      fmt.Println(m)
   }else{
      fmt.Println("no mssage from sercive2")
   }
}
}

mssGen方法：
func msgGen(name string) chan string {
   c := make(chan string)
   go func(){
      i := 0
  for {
         time.Sleep(time.Duration(rand.Intn(5000)) * time.Millisecond)
         c <- fmt.Sprintf("service: %s, message ：%d", name, i)
         i++
      }
   }()
   return c
}
列印結果：
service: service1, message ：0
no mssage from sercive2
service: service1, message ：1
service: sercive2, message ：0
service: service1, message ：2
service: sercive2, message ：1
service: service1, message ：3
no mssage from sercive2
service: service1, message ：4
no mssage from sercive2
service: service1, message ：5
no mssage from sercive2

2.超時等待
其邏輯和非阻塞等待類似，我們需要使用time.after通道來控制時間：
func timeoutWait(c chan string, tm time.Duration) (string, bool){
   select{
   case m := <-c:
      return m, true
 case <- time.After(tm):
      return "", false
  }
}
呼叫：
func main() {
   m1 := msgGen("service1")
   m2 := msgGen("sercive2")
   for{
      fmt.Println(<-m1)
      if m, ok := timeoutWait(m2, time.Second); ok{
         fmt.Println(m)
      }else{
         fmt.Println("timeout")
      }
   }
}
mssGen方法不變
列印結果：
service: service1, message ：0
service: sercive2, message ：0
service: service1, message ：1
timeout
service: service1, message ：2
service: sercive2, message ：1
service: service1, message ：3
timeout
service: service1, message ：4
service: sercive2, message ：2

任務中斷/退出
當main結束時，會將所有的goroutine都殺掉，但是如果中途一下任務沒有做完，我們希望外層可以通知我們，“說你要退出了”，那麼我們如何實現呢？這裡我們需要再次引入done用於，主goroutine給goroutine發資訊
這是任務中斷/退出的核心程式碼和邏輯：

func msgGen(name string, done chan struct{}) chan string {  //done也可使用bool，struct{}內部沒資料，比bool更節約空間
  c := make(chan string)
   go func(){
      i := 0
  for {
         select {
         case <-time.After(time.Duration(rand.Intn(5000)) * time.Millisecond):  //每隔time.Duration(rand.Intn(5000)) * time.Millisecond的時間就會向c中發資料
            c <- fmt.Sprintf("service: %s, message ：%d", name, i)
         case <-done:  //當main中向done中發資料，程式就會執行該case，最後退出
            fmt.Println("cleaing up")
            return
  }
         i++
      }

   }()
   return c
}

main：

func main() {
   done := make(chan struct{})
   m1 := msgGen("service1", done)
   for i := 0; i < 5; i++{   //列印五遍就結束
      fmt.Println(<-m1)
      if m, ok := timeoutWait(m1, time.Second); ok{
         fmt.Println(m)
      }else{
         fmt.Println("timeout")
      }
   }
   //main通知其他goroutine，main將結束向done中發資料
   done <- struct{}{} //第一個{}是結構定義，第二個{}是初始化
  time.Sleep(time.Second)   //防止main瞬間退出
}

列印結果：
service: service1, message ：0
timeout
service: service1, message ：1
timeout
service: service1, message ：2
timeout
service: service1, message ：3
timeout
service: service1, message ：4
timeout
cleaing up

優雅退出
在3.中講到任務中斷，在這個過程中，只是main(主goroutine)給其他goroutine發通知，說我要退了，沒有真正的互動，這就顯得不那麼優雅，現在我們需要優雅的退出，如：男：我走了；女：好的，你走吧。這是不是很優雅，相互應答，好下面就來做這件事：

方法一：在“中斷任務”的基礎上增加一個chan boo型別的dones，用來回應，看程式碼：

func msgGen(name string, done chan struct{}, dones chan bool) chan string {  //done也可使用bool，struct{}內部沒資料，比bool更節約空間
  c := make(chan string)
   go func(){
      i := 0
  for {
         select {
         case <-time.After(time.Duration(rand.Intn(2000)) * time.Millisecond):
            c <- fmt.Sprintf("service: %s, message ：%d", name, i)
         case <-done:
            fmt.Println("cleaing up")
            time.Sleep(2 * time.Second)
            fmt.Println("cleaing done")
            dones <- true
 return  }
         i++
      }

   }()
   return c
}

func main() {
   done := make(chan struct{})
   dones := make(chan bool)
   m1 := msgGen("service1", done, dones)
   for i := 0; i < 5; i++{
      fmt.Println(<-m1)
      if m, ok := timeoutWait(m1, time.Second); ok{
         fmt.Println(m)
      }else{
         fmt.Println("timeout")
      }
   }
   done <- struct{}{} //第一個{}是結構定義，第二個{}是初始化
  <-dones
}

列印結果：
service: service1, message ：0
timeout
service: service1, message ：1
timeout
service: service1, message ：2
service: service1, message ：3
service: service1, message ：4
timeout
service: service1, message ：5
service: service1, message ：6
cleaing up
cleaing done

方法二
不需要增加引數，只需要將chan struct{}型別的done在
go func{……}()中新增：done <- struct{}{}即可，看程式碼

func msgGen(name string, done chan struct{}) chan string {  //done也可使用bool，struct{}內部沒資料，比bool更節約空間
  c := make(chan string)
   go func(){
      i := 0
  for {
         select {
         case <-time.After(time.Duration(rand.Intn(2000)) * time.Millisecond):
            c <- fmt.Sprintf("service: %s, message ：%d", name, i)
         case <-done:
            fmt.Println("cleaing up")
            time.Sleep(2 * time.Second)
            fmt.Println("cleaing done")
            done <- struct{}{}
 return  }
         i++
      }

   }()
   return c

}

func main() {
   done := make(chan struct{})
   dones := make(chan bool)
   m1 := msgGen("service1", done, dones)
   for i := 0; i < 5; i++{
      fmt.Println(<-m1)
      if m, ok := timeoutWait(m1, time.Second); ok{
         fmt.Println(m)
      }else{
         fmt.Println("timeout")
      }
   }
   done <- struct{}{} //第一個{}是結構定義，第二個{}是初始化
  <-done
}

列印結果：
service: service1, message ：0
timeout
service: service1, message ：1
timeout
service: service1, message ：2
service: service1, message ：3
service: service1, message ：4
timeout
service: service1, message ：5
service: service1, message ：6
cleaing up
cleaing done

golang併發程式設計的內容我們就介紹到這裡了，併發程式設計和和傳統程式設計不同，併發程式設計的跳躍性較大，更難理解，大家加油！

本作品採用《CC 協議》，轉載必須註明作者和本文連結

「Golang成長之路」併發任務的控制

併發任務的控制

相關文章