Issue with runtime.LockOSThread() and runtime.UnlockOSThread

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.

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)
}

What runtime.LockOSThread does is prevent any other goroutine from running on the same thread. It forces the runtime to create a new thread and run Routine2 there. They are still running concurrently but on different threads.

You need to use sync.Mutex or some channel magic instead.

You rarely need to use runtime.LockOSThread but it can be useful for forcing some higher priority goroutine to run on a thread of it's own.

package main

import (
	"fmt"
	"sync"
	"time"
)

var m sync.Mutex

func printing(s string) {
	m.Lock() // Other goroutines will stop here if until m is unlocked
	fmt.Println(s)
	m.Unlock() // Now another goroutine at "m.Lock()" can continue running
}

func main() {
	for i := 0; i < 10; i++ {
		go printing(fmt.Sprintf("Goroutine #%d", i))
	}
	
	<-time.After(3e9)
}

I think, this is because of runtime.LockOSThread(),runtime.UnlockOSThread does not work all time. It totaly depends on CPU, execution environment etc. It can't be forced by anyother way.