Threadsafe redis client

I'm using goredis and as far as I can see - there is a connection pool when client connects to redis server. I don't know how to query redis server and to be sure that it is in a thread-safe way.

Currently I do this:

I am creating global pointer client: client *goredis.Redis
Then I do this:

go func () {
    http.HandleFunc("/send_data/", trackHandler)
    http.HandleFunc("/init/", initHandler)
    http.ListenAndServe(":8000", nil)
} ()

So now I want to use client in trackHandler and initHandler but I am concerned that there is no syncing in any way when executing queries. Is it possible to mess-up things in this way. What is the canonical way to solve this issue in golang?

Also I am wondering how this works in redis-py.
I've seen this thread:

> In general, I suggest you either:
>
> a. create a global redis client instance and have your code use that.
> b. create a global connection pool and pass that to various redis instances throughout your code.
>
> Both of these accomplish the same thing. Both are threadsafe.

How is it done in the first scenario?

The client has a connection pool which is thread safe, and whenever you execute a command, the client tries to get a connection from the pool. Thus even though the client has no lock, it's still thread safe, so you should be fine with a global client.

See here - how the Dial function creates a new connection pool:
https://github.com/xuyu/goredis/blob/master/redis.go#L432

And here for an example of locking in the connectino pool itself.
https://github.com/xuyu/goredis/blob/master/redis.go#L287

Re redis-py - It creates its own internal connection pool if you don't use one explicitly, so it's thread safe because under the hood the connections are pooled globally. Same thing basically.