与runtime.LockOSThread（）和runtime.UnlockOSThread有关的问题

Question

I have a code like,

Routine 1 {
runtime.LockOSThread()
print something
send int to routine 2
runtime.UnlockOSThread

}

Routine 2 {
runtime.LockOSThread()
print something
send int to routine 1
runtime.UnlockOSThread

}


main {
go Routine1
go Routine2
}

I use run time lock-unlock because, I don't want that printing of Routine 1 will mix with Routine 2. However, after execution of above code, it outputs same as without lock-unlock (means printing outputs mixed). Can anybody help me why this thing happening and how to force this for happening.

NB: I give an example of print something, however there are lots of printing and sending events.

Answer 1

If you want to serialize "print something", e.g. each "print something" should perform atomically, then just serialize it.

You can surround "print something" by a mutex. That'll work unless the code deadlock because of that - and surely it easily can in a non trivial program.

The easy way in Go to serialize something is to do it with a channel. Collect in a (go)routine everything which should be printed together. When collection of the print unit is done, send it through a channel to some printing "agent" as a "print job" unit. That agent will simply receive its "tasks" and atomically print each one. One gets that atomicity for free and as an important bonus the code can not deadlock easily no more in the simple case, where there are only non interdependent "print unit" generating goroutines.

I mean something like:

func printer(tasks chan string) {
        for s := range tasks {
                fmt.Printf(s)
        }
}

func someAgentX(tasks chan string) {
        var printUnit string
        //...
        tasks <- printUnit
        //...
}

func main() {
        //...
        tasks := make(chan string, size)
        go printer(tasks)
        go someAgent1(tasks)
        //...
        go someAgentN(tasks)
        //...
        <- allDone
        close(tasks)
}