Usage of global variables with Http handlers in Golang

I know there are some questions and posts/articles regarding this question, but from my newbie view, not exactly.
The thing is, I've got a main program listening to a port and redirecting the calls to a specific handler. The typical structure:

func main() {
    http.HandleFunc("/something", specificHandler)
    http.ListenAndServe(":8080", nil)
}

With the handler being something like:

func specificHandler(w http.ResponseWriter, r *http.Request) {
    somepackage.foo()
}

Then somepackage, which contains the function foo, has some global variables, basically because they're needed for functions to share (e.g., when using a priority queue implemented with a container/heap, which will get the priorities in the Swap function from a global matrix of distances which is of course changable). And many other examples. In summary, global variables...

The problem is, as you might see, that those variables are shared among all the calls to the handler. And that's bad.

How can I actually solve this? There must be an easy to way to do it that I haven't got to yet, because it looks like something so usual...

Thanks in advance.

EDIT

To make it clearer. For example, in my A* package, I've got the following global variables:

var openVerticesAS PriorityQueueAStar

// which vertices are closed
var closedVertices map[int]bool

// which vertices are currently open
var openVertices map[int]bool

// cost from start to node
var gScore map[int]float64

// cost from start to end, passing by node i (g+h)
var fScore map[int]float64

Then, PriorityQueueAStar is implemented as follows:

type PriorityQueueAStar []int // rel id

func (pq PriorityQueueAStar) Len() int { return len(pq) }

func (pq PriorityQueueAStar) Empty() bool { return len(pq) == 0 }

func (pq PriorityQueueAStar) Less(i, j int) bool {
    return fScore[pq[i]] < fScore[pq[j]]
}

func (pq PriorityQueueAStar) Swap(i, j int) {
    pq[i], pq[j] = pq[j], pq[i]
}

func (pq *PriorityQueueAStar) Push(x interface{}) {
    *pq = append(*pq, x.(int))
}

func (pq *PriorityQueueAStar) Pop() interface{} {
    old := *pq
    n := len(old)
    rel := old[n-1]
    *pq = old[0 : n-1]
    return rel
}

func (pq PriorityQueueAStar) Top() interface{} {
    return pq[0]
}

The question then, is, how do I keep doing this without having all those maps as global variables? If they are part of the struct, how do I access the struct from the priority queue functions?

When your handler needs a variable, usually that means you should implement the Handler interface instead of providing a HandlerFunc function.

Here is a BAD example (using global variables):

var globalThing string

func specificHandler(w http.ResponseWriter, r *http.Request) {
	w.Write(globalConfigThing)
}

func main() {
	globalThing = "Hello world!"
	http.HandleFunc("/something", specificHandler)
	http.ListenAndServe(":8080", nil)
}

Here is a BETTER example (not using global variables):

type specificHandler struct {
	Thing string
}

func (h *specificHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	w.Write(h.Thing)
}

func main() {
	http.Handle("/something", &specificHandler{Thing: "Hello world!"})
	http.ListenAndServe(":8080", nil)
}

As you can see, a Handler can encapsulate variables.

For completeness, the other approach is to use a function closure. This works well for once-off handlers but is not re-usable and is harder to write unit tests for.

func main() {
	scopedThing := "Hello world!"
	http.HandleFunc("/something", func (w http.ResponseWriter, r *http.Request) {
		w.Write(scopedThing)
	})
	http.ListenAndServe(":8080", nil)
}

Done correctly, you can now avoid global variables in your package somepackage by passing them as arguments, etc.

EDIT: For example, you can define your handler struct with several PriorityQueueAStar fields from the somepackage package:

type specificHandler struct {
	QueueA somepackage.PriorityQueueAStar
	QueueB somepackage.PriorityQueueAStar
	QueueC somepackage.PriorityQueueAStar
}

func (h *specificHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
	h.QueueA.Push(h.QueueB.Pop)
	h.QueueB.Push(h.QueueC.Pop)
	w.Write([]byte("Queues pushed and popped"))
}

The closure method was mentioned by chowey, but had a caveat that it isn't testable or reusable. It is actually testable and reusable if you have a function to return the closure. For some types of data this may make for a cleaner abstraction and implementation:

func handleThing(thing string) func(w http.ResponseWriter, r *http.Request) {
    return func(w http.ResponseWriter, r *http.Request) {
        w.Write(thing)
    }
}

func main() {
    http.HandleFunc("/something", handleThing("Hello world!"))
    http.ListenAndServe(":8080", nil)
}