怎么把全局共享修改为并发的

有没有 GO 的大佬，能否帮忙修改这个反向代理的代码，是从 redis 里拿出 SSL 证书和反代的目标地址，
目前主要是全局变量的问题，要修改为并发安全（刚入门 GO 还没研究明白），
问 AI 也没能解决他只是建议用上下文（或许是免费的 AI 不行）。
非常感谢！

package main

import (
	"context"
	"crypto/tls"
	"errors"
	"fmt"
	"github.com/redis/go-redis/v9"
	"net"
	"net/http"
	"net/http/httputil"
	"net/url"
	"strings"
	"time"
)

var (
	httpAddr    = ":80"
	httpsAddr   = ":443"
	redisClient *redis.Client
)

type proxyInfo struct {
	targetUrl       string
	requestPath     string
	requestRawQuery string
	requestHeader   map[string]string
}

func init() {
	redisClient = redis.NewClient(&redis.Options{
		Addr:     "127.0.0.1:6379",
		Password: "",
		DB:       0,
	})
}

func main() {
	//创建 httpTCP
	tcpConn, err := net.Listen("tcp", httpAddr)
	if err != nil {
		panic(err)
	}
	defer tcpConn.Close()

	//创建 httpsTCP
	tcpsConn, err := net.Listen("tcp", httpsAddr)
	if err != nil {
		panic(err)
	}
	defer tcpsConn.Close()

	pi := &proxyInfo{}

	tlsConn := tls.NewListener(tcpsConn, &tls.Config{
		GetCertificate: func(clientHello *tls.ClientHelloInfo) (*tls.Certificate, error) {
			return pi.getCertificate(clientHello)
		},
	})

	httpServer := &http.Server{
		Handler: pi.proxyRequestHandler(),
	}

	go func() {
		httpServer.Serve(tcpConn)
	}()

	go func() {
		httpServer.Serve(tlsConn)
	}()

	select {}
}

// 反向代理
func (pi *proxyInfo) newProxy() (*httputil.ReverseProxy, error) {

	targetUrl, err := url.Parse(pi.targetUrl)
	if err != nil {
		return nil, err
	}

	targetUrl.Path = pi.requestPath
	targetUrl.RawQuery = pi.requestRawQuery

	fmt.Println("反代的地址：", targetUrl.String())
	proxy := httputil.NewSingleHostReverseProxy(targetUrl)

	//连接配置
	proxy.Transport = &http.Transport{
		Proxy: http.ProxyFromEnvironment,
		DialContext: (&net.Dialer{
			Timeout:   60 * time.Second,
			KeepAlive: 60 * time.Second,
		}).DialContext,
		ForceAttemptHTTP2:     true,
		MaxIdleConns:          100,
		IdleConnTimeout:       90 * time.Second,
		TLSHandshakeTimeout:   10 * time.Second,
		ExpectContinueTimeout: 1 * time.Second,
		MaxIdleConnsPerHost:   20,
	}

	originalDirector := proxy.Director
	proxy.Director = func(req *http.Request) {
		originalDirector(req)
		req.URL = targetUrl
		req.Host = targetUrl.Host
		for k, v := range pi.requestHeader {
			//fmt.Println("添加请求头：", k, v)
			req.Header.Set(k, v)
		}
	}

	proxy.ModifyResponse = pi.modifyResponse()
	proxy.ErrorHandler = pi.errorHandler()
	return proxy, nil
}

// 根据客户端 ClientHello 查询 redis 里域名信息
func (pi *proxyInfo) getCertificate(clientHello *tls.ClientHelloInfo) (*tls.Certificate, error) {
	hostName := clientHello.ServerName

	//判断不符合域名长度的 SSL 请求
	if len(hostName) < 4 {
		return nil, errors.New(hostName + ",域名长度不符合")
	}

	//查询 redis 里的域名 SSL 证书
	hostConf, err := pi.getHostConf(hostName)
	if err != nil {
		return nil, err
	}

	certPublic := []byte(hostConf["certPublic"])
	certPrivate := []byte(hostConf["certPrivate"])

	certAndKey, err := tls.X509KeyPair(certPublic, certPrivate)
	if err != nil {
		return nil, err
	}

	return &certAndKey, nil
}

// 处理代理请求
func (pi *proxyInfo) proxyRequestHandler() http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {

		//不是 https 的请求
		if r.TLS == nil {
			_, err := pi.getHostConf(getHostName(r.Host))
			if err != nil {
				w.WriteHeader( http.StatusBadRequest)
				w.Write([]byte(err.Error()))
				return
			}
		}

		pi.requestPath = r.URL.Path
		pi.requestRawQuery = r.URL.RawQuery

		requestHeader := make(map[string]string)
		requestHeader["Referer"] = pi.targetUrl
		requestHeader["User-Agent"] = r.Header.Get("User-Agent")
		requestHeader["Accept"] = r.Header.Get("Accept")
		pi.requestHeader = requestHeader

		//反代
		proxy, err := pi.newProxy()
		if err != nil {
			panic(err)
		}

		proxy.ServeHTTP(w, r)
	}
}

// 修改 http 响应数据
func (pi *proxyInfo) modifyResponse() func(*http.Response) error {
	return func(r *http.Response) error {
		typeStr := r.Header.Get("Content-Type")
		fmt.Println(typeStr)
		return nil
	}
}

// 错误处理器
func (pi *proxyInfo) errorHandler() func( http.ResponseWriter, *http.Request, error) {
	return func(w http.ResponseWriter, req *http.Request, err error) {
		fmt.Printf("Got error while modifying response: %v \n", err)
		w.WriteHeader( http.StatusInternalServerError)
		w.Write([]byte("server error"))
		return
	}
}

// 获取域名的配置信息
func (pi *proxyInfo) getHostConf(hostName string) (map[string]string, error) {
	hostConf, err := redisClient.HGetAll(context.Background(), hostName).Result()
	if err != nil {
		return nil, err
	}

	//模拟返回 SSL 证书
	//hostConf["certPublic"] = "-----BEGIN CERTIFICATE-----\n"
	//hostConf["certPrivate"] = "-----BEGIN CERTIFICATE-----\n"
	//反代的目标网址
	//hostConf["targetUrl"] = "https://www.baidu.com"

	//反代的目标网址
	pi.targetUrl = hostConf["targetUrl"]

	return hostConf, nil
}

// 获取不含端口的 host
func getHostName(rawUrl string) string {
	if !strings.HasPrefix("http://", rawUrl) || !strings.HasPrefix("https://", rawUrl) {
		rawUrl = "http://" + rawUrl
	}
	u, err := url.Parse(rawUrl)
	if err != nil {
		return ""
	}
	return u.Hostname()
}