How to create named mutex in Golang?

I am fairly new to Golang and trying to create a named mutex. I am trying to replicate:

    hMutex = CreateMutex( 
    NULL,                        // default security descriptor
    FALSE,                       // mutex not owned
    TEXT("NameOfMutexObject"));  // object name

The examples I see in sync don't appear to illustrate named mutexes.

Named mutexes (in Windows) are really intended for use when sharing a mutex between/across processes and/or to simplify referencing the same mutex from different parts of the code in a single process (creating the mutex in one place and "opening" an existing mutex in other places).

A mutex in Go is more similar to a critical section in Windows (in concept at least, I cannot speak to the underlying implementation).

In Windows, named mutexes enable different processes to share mutexes by obtaining a reference to one, by its name.

To share a mutex in Go you either declare the mutex such that it is referencable where required or pass a reference to any functions that need it.

It follows that mutexes (in Go) cannot be shared between processes; if that's your use case then you will need to explore other cross-process synchronization mechanisms. But if all you need is to synchronize threads in the same process, just use a mutex and don't worry about the fact that you can't git it a name.

Here is an example of a named mutex using sync - is this what you are looking for?

package main

import (
	"fmt"
	"sync"
)

var mutexMap sync.Map

func createMutex(name string) *sync.Mutex {
	mutex, ok := mutexMap.Load(name)
	if !ok {
		newMutex := &sync.Mutex{}
		mutex, _ = mutexMap.LoadOrStore(name, newMutex)
	}
	return mutex.(*sync.Mutex)
}

func main() {
	hMutex := createMutex("NameOfMutexObject")
	hMutex.Lock()
	fmt.Println("Locked Mutex: NameOfMutexObject")
	hMutex.Unlock()
	fmt.Println("Unlocked Mutex: NameOfMutexObject")
}