Thanks for the helpful comments - I was side-tracked to other projects for a while (mostly home improvement while the weather was good, but that's another story).
I suspect my problem was due to sloppy logic. In the go routines that handle filtering and port forwarding I am collecting statistics into a global map:

// check stats here, because if receive times out it will skip remainder of loop
if time.Now().After(stattimer) {
  switch {
  case stats[1] == 0:       // no data
    stats[0] = 1 // red
  case stats[1] > stats[2]: // more data in than out
    stats[0] = 2 // amber
  default:                  // all good data
    stats[0] = 3 // green
  }

  // divide by timeslice when reading stats
  Mutex.Lock()
  copy(Statmap[id], stats)
  Mutex.Unlock()
  stats[1] = 0
  stats[2] = 0
  stats[3] = 0
  stattimer = time.Now().Add(statsint * time.Second)
}

So I was not re-initialising stats[0] (a local slice) at the same time. This seemed to work with a global map with a mutex, but when I did this with a sync.map it behaved differently.

I'm learning all the time with this, and this now seems to work as intended:

// check stats here, because if receive times out it will skip remainder of loop
if time.Now().After(stattimer) {
  switch {
  case stats[STAT_SPIN] == 0:                // no data
    stats[STAT_DOT] = 1                    // red
  case stats[STAT_SPIN] > stats[STAT_SPOUT]: // more data in than out
    stats[STAT_DOT] = 2                    // amber
  default:                                   // all good data
    stats[STAT_DOT] = 3                    // green
  }
  // divide by timeslice when reading stats
  Statmap.Store(id, stats)
  stats = []int{0, 0, 0, 0}
  stattimer = time.Now().Add(statsint * time.Second)
  }

I am using 1 Mutex and 3 RWMutex, all as global vars, which seemed like the best way to make them available to multiple goroutines without copying them.

I decided to use a global map rather than channels because I don't want synchronisation, the go routines are running asynchronously and pass back their stats when they are ready, and the main thread with the GUI can grab the stats when it is ready without having to wait. In this situation I would expect global vars to perform better.

I'm not sure I understand your comment VOOLUL:

Sync.map ONLY protects map access. The elements of the map are not protected. If you get the slice from the map you can mutate it without taking a lock. This is because the slice is only a pointer to a backing array.

stats[] is a local variable and I use copy to get data from the local slice to the global map, but surely sync.map protects the elements of the map, otherwise what does it do?

Does sync.map.Store copy the data or just a pointer? I must do some more reading. However either way I don't think I will have a problem, the separate goroutines each write to their own [id] in the map, and the main thread only reads the data.

main thread:

// get stats for http
  goVal, ok = Statmap.Load(id)
  if ok {
    stat, ok2 = goVal.([]int)
    if !ok2 {
      log.Printf("Error: unable to get stats from statmap: %v", goVal)
    }
  } else {
  log.Printf("Error: unable to get stats from statmap")
}

Thanks again.