Is there a better way to use channels to ensure synchronous access to the map?

I'm using Go maps as an in memory cache and channels to ensure synchronous access.

My "session" package defines the cache as: map[string]*SessionData

SessionData is a struct also defined in the package, along with other access functions as seen in the code.

GetWebPage(rw http.ResponseWriter, req *http.Request) {
var sd *session.SessionData
var sessTkn string

cookie, err := req.Cookie("sesstoken")

if err == nil { // cookie found
	sessTkn = cookie.Value
	// Check for cache entry for this token,
	// using a channel to protect the map and return
	// a pointer to the cached data if it exists
	sdc := make(chan *session.SessionData, 1)
	go session.GetSessionFromCache(sessTkn, sdc)
	sd = <-sdc
	
	if sd == nil { // sessTkn not in the cache

		// This is test data to simplify example 
		sv := make([]string, 4)
		sv[0] = sessTkn
		iv := make([]int, 3)
		iv[0] = 100
		iv[1] = 1000

		sdc := make(chan *session.SessionData, 1)
		go session.NewSessionData(sv, iv, false, false, sdc)
		session.SC[sessTkn] = <-sdc
	}

// Is this necessary? Is there a better way?
// ---------------------------------------		
	if sd == nil {
		sdc = make(chan *session.SessionData, 1)
		go session.GetSessionFromCache(sessTkn, sdc)
		sd = <-sdc		
	}
// ---------------------------------------		

	fmt.Println(sd) // just to prove that it works in both cases
}	
// The rest of the handler code follows

Use a mutex to protect the map. A mutex is often simpler than using channels & goroutines to protect a resource.

var (
  mu sync.Mutex
  cache = make(map[string]*SessionData)
)

func GetSessionFromCache(sessTkn string) *SessionData {
  mu.Lock()
  defer mu.Unlock()
  sd := cache[sessTkn]
  if sd != nil {
      return sd
  }
  sd := &SessionData{
     // initialize new value here
  }
  cache[sessTkn] = sd
  return sd
}

Use it like this:

sd := session.GetSessionFromCache(sessTkn) 

Using channels for this particular case have no additional benefit. If you think about it, even with creating new channels, you can still only have one goroutine that can access the map. Since there is no concurrency benefit here, just use sync.Mutex.

package session

import "sync"

var cache = struct {
  sync.Mutex
  list map[string]*SessionData
}{
  list: make(map[string]*SessionData),
}

func GetSessionFromCache(token string) *SessionData {
  cache.Lock()
  defer cache.Unlock()
  return cache.list[token]
}

Then, no need for a new goroutine. Just call it directly.

sd := session.GetSessionFromCache(sessTkn)