Il runtime.Lockouthread consente ai goroutini figli di essere eseguiti nello stesso thread del sistema operativo?

Question

Capisco che in Go, runtime.LockOSThread() si associ una goroutine a un thread del sistema operativo e non si consenta l'esecuzione di altre goroutine in tale thread. Questo vale anche per le goroutine infantili?

Ad esempio:

runtime.LockOSThread() 
go func() { 
    go func() { 
     // Do something 
    }() 
    // Do something 
}() 

fare entrambe queste goroutines eseguire in un unico ed esclusivo filo OS o solo il primo?

Answer 1

The documentation per runtime.LockOSThread dice:

fili LockOSThread la chiamata goroutine al suo attuale thread di sistema operativo. Fino a quando la goroutine di chiamata non si chiude o chiama Unlockisthread, verrà sempre eseguito in tale thread, e nessun'altra goroutine può.

^{(sottolineatura mia)}

Ciò significa che se una certa implementazione di Go ha fatto quello che stai chiedendo, sarebbe difettosa.

Per chiarire: se una goroutine aveva prenotato un filo e un'altra goroutine eseguita su quella stessa filettatura; è quello che sarebbe sbagliato.

Answer 2

Possiamo controllare utilizzando del pthread.h pthread_self:

package main 

// #include <pthread.h> 
import "C" 
import (
    "fmt" 
    "runtime" 
) 

func main() { 
    runtime.GOMAXPROCS(runtime.NumCPU()) 
    ch1 := make(chan bool) 
    ch2 := make(chan bool) 
    fmt.Println("main", C.pthread_self()) 
    go func() { 
     runtime.LockOSThread() 
     fmt.Println("locked", C.pthread_self()) 
     go func() { 
      fmt.Println("locked child", C.pthread_self()) 
      ch1 <- true 
     }() 
     ch2 <- true 
    }() 
    <-ch1 
    <-ch2 
} 

Sulla mia macchina viene stampato qualcosa del genere, e mainlocked sempre di essere a volte lo stesso, ma a volte diversa:

main 139711253194560 
locked 139711219787520 
locked child 139711236572928 

EDIT Ho dimenticato GOMAXPROCS. Aggiunto, i risultati sono diversi ora.