理解Goroutine

Go語言裏面的併發使用的是Goroutine，Goroutine能夠看作一種輕量級的線程，或者叫用戶級線程。與Java的Thread很像，用法很簡單：

go fun(params);

至關於Java的

new Thread(someRunnable).start();

 

雖然相似，可是Goroutine與Java Thread有着很大的區別。

 

Java裏的Thread使用的是線程模型的一對一模型，每個用戶線程都對應着一個內核級線程。

上圖有兩個CPU，而後有4個Java thread，每一個Java thread其實就是一個內核級線程，由內核級線程調度器進行調度，輪流使用兩個CPU。內核級線程調度器具備絕對的權力，因此把它放到了下面。內核級線程調度器使用公平的算法讓四個線程使用兩個CPU。

 

Go的Goroutine是用戶級的線程。一樣是4個Goroutine，可能只對應了兩個內核級線程。Goroutine調度器把4個Goroutine分配到兩個內核級線程上，而這兩個內核級線程對CPU的使用由內核線程調度器來分配。

 

與內核級線程調度器相比，Goroutine的調度器與Goroutine是平等的，因此把它和Goroutine放到了同一個層次。調度器與被調度者權力相同，那被調度者就能夠不聽話了。一個Goroutine若是佔據了CPU就是不放手，調度器也拿它沒辦法。

 

一樣是下面一段代碼：

void run() {
  int a = 1;
  while(1==1) {
   a = 1;
  }
}

在Java裏，若是起多個這樣的線程，它們能夠平等的使用CPU。可是在Go裏面，若是起多個這樣的Goroutine，在啓動的內核級線程個數必定狀況下（一般與CPU個數相等），那麼最早啓動的Goroutine會一直佔據CPU，其它的Goroutine會starve，餓死，由於它不能主動放棄CPU，不配合別人工做。說到配合工做，那就須要說一下協程（coroutine，能夠當作cooperative routine)，協程須要相互合做，互相協助，才能正常工做，因此叫作協程。

 

 協程並不須要一個調度器，它是徹底靠互相之間協調來工做的。協程的定義在學術上很抽象，目前實際應用中，協程一般是使用單個內核級線程，用來把異步編程中使用的難懂的callback方式改爲看上去像同步編程的樣子。

好比nodejs是異步單線程事件驅動的，在一段代碼中若是有屢次異步操做，好比先調用一個支付系統，獲得結果後再更新數據庫，那麼可能須要嵌套使用callback。pay函數是一個調用支付系統的操做，異步發出請求後就返回，而後等支付完成的事件後觸發第一個回調函數，這個函數是更新數據庫，又是一個異步操做，等這個異步操做完成後，再次觸發返回更新結果的回調函數。 這裏只有兩個異步操做，若是多的話，有可能會有不少嵌套。

pay(amount, callback(payamount) {
 update(payamount, callback(result) {
   return result;
})});

而使用協程，能夠看上去像是同步操做

pay(amount){
  //異步，馬上返回
  //payamount須要操做完成後才能被賦值
 payamount = dopay(amount);
 yeild main;//把控制權返回主routine
 //dopay事件完成後，主routine會調起這個routine,
 //繼續執行doupdate
 result=doupdate(payamount); 
 yeild main;  //再次把控制權返回主routine
 return result;
}

（以上都是僞代碼）

把原來的各類嵌套callback改爲協程，那麼邏輯就會清晰不少。

 

Goroutine與Coroutine不同，開發者並不須要關心Goroutine如何被調起，如何放棄控制權，而是交給Goroutine調度器來管理。開發者不用關心，可是Go語言的編譯器會替你把工做作了，由於Goroutine必須主動交出控制權才能由調度器統一管理。首先咱們能夠認爲寫上面那種死循環並且不調用任何其餘函數的Goroutine是沒意義的，若是真在實際應用中寫出這樣的代碼，那開發者不是一個合格的程序員。一個Goroutine總會調用其餘函數的，一種調用是開發者本身寫的函數，一種是Go語言提供的API。那編譯器以及這些API就能夠作文章了。

 

好比

void run() {
  int a = 0;
  int b = 1;
  a = b * 2;
  for(int i = 0; i < 100; i++) {
    a = func1(a);
 }
}

那麼編譯器可能會在調用其餘函數的地方偷偷加上幾條語句，好比：

void run() {
  int a = 0;
  int b = 1;
  a = b * 2;
  for(int i = 0; i < 100; i++) {
   //進入調度器，或者以必定機率進入調度器
   schedule();  
   a = func1(a);
  }
}

再好比

void run() {
  socket = new socket();
 while(buffer = socker.read()) {
  deal(buffer);
 }
}

socker.read()是Go語言提供的一個系統函數，那麼Go語言可能在這裏面加點操做，讀完數據後，進入調度器，讓調度器決定這個Goroutine是否繼續跑。

下面這段Go語言代碼，把內核級線程設成2個，那麼主線程會餓死，而在func1里加一個sleep就能夠了，這樣func1纔有機會放棄控制權。

固然Go語言的調度器要比這複雜的多。Goroutine與協程仍是有區別的，實現原理是同樣的，可是Goroutine的目的是爲了實現併發，在Go語言裏，開發者不能建立內核級線程，只能建立Goroutine，而協程的目的如上面所示，目前比較常見的用途就是上面這個。Go語言適合編寫高併發的應用，由於建立一個Goroutine的代價很低，並且Goroutine切換上下文開銷也很低，與建立內核級線程相比，Goroutine的開銷可能只是幾十分之一甚至幾百分之一，並且它不佔內核空間，每一個內核級線程都會佔很大的內核空間，能建立的線程數最多也就幾千個，而Goroutine能夠很輕鬆的建立上萬個。

 

Goroutine底層的實現，在Linux上面是用makecontext，swapcontext，getcontext，setcontext這幾個函數實現的，這幾個系統調用能夠實現用戶空間線程上下文的保存和切換。