在CentOS系统下使用Go语言实现缓存技术，可以采用多种方式。以下是一些常见的缓存技术和相应的实现方法：

1. 内存缓存

内存缓存是最快的缓存方式，适用于需要快速访问的数据。

使用sync.Map

Go标准库中的sync.Map是一个并发安全的map，适合用作简单的内存缓存。

package main

import (
 "fmt"
 "sync"
 "time"
)

var cache = sync.Map{}

func getFromCache(key string) (interface{}, bool) {
 if value, found := cache.Load(key); found {
  return value, true
 }
 return nil, false
}

func setToCache(key string, value interface{}) {
 cache.Store(key, value)
}

func main() {
 key := "testKey"
 value := "testValue"

 // 设置缓存
 setToCache(key, value)

 // 获取缓存
 if val, found := getFromCache(key); found {
  fmt.Println("Cache hit:", val)
 } else {
  fmt.Println("Cache miss")
 }

 // 模拟缓存过期
 time.Sleep(5 * time.Second)
 if _, found := getFromCache(key); !found {
  fmt.Println("Cache expired")
 }
}

2. 分布式缓存

分布式缓存适用于需要在多个服务之间共享缓存数据的场景。

使用Redis

Redis是一个流行的内存数据库，可以用作分布式缓存。

首先，安装Redis服务器并启动它：

sudo yum install redis
sudo systemctl start redis

然后，在Go程序中使用Redis客户端库（如go-redis）来操作Redis。

package main

import (
 "context"
 "fmt"
 "github.com/go-redis/redis/v8"
 "time"
)

var rdb *redis.Client

func init() {
 rdb = redis.NewClient(&redis.Options{
  Addr:     "localhost:6379",
  Password: "", // no password set
  DB:       0,  // use default DB
 })
}

func getFromCache(ctx context.Context, key string) (string, error) {
 val, err := rdb.Get(ctx, key).Result()
 if err == redis.Nil {
  return "", fmt.Errorf("key does not exist")
 } else if err != nil {
  return "", err
 }
 return val, nil
}

func setToCache(ctx context.Context, key string, value string, expiration time.Duration) error {
 return rdb.Set(ctx, key, value, expiration).Err()
}

func main() {
 ctx := context.Background()
 key := "testKey"
 value := "testValue"

 // 设置缓存，过期时间为10秒
 err := setToCache(ctx, key, value, 10*time.Second)
 if err != nil {
  fmt.Println("Error setting cache:", err)
  return
 }

 // 获取缓存
 if val, err := getFromCache(ctx, key); err == nil {
  fmt.Println("Cache hit:", val)
 } else {
  fmt.Println("Cache miss or error:", err)
 }

 // 等待缓存过期
 time.Sleep(11 * time.Second)
 if _, err := getFromCache(ctx, key); err != nil {
  fmt.Println("Cache expired")
 }
}

3. 文件缓存

文件缓存适用于数据量不大且不需要频繁更新的缓存。

使用文件系统

可以使用Go的os和io/ioutil包来读写文件。

package main

import (
 "fmt"
 "io/ioutil"
 "os"
 "time"
)

const cacheDir = "./cache"

func getFromCache(filePath string) (string, error) {
 data, err := ioutil.ReadFile(filePath)
 if err != nil {
  return "", err
 }
 return string(data), nil
}

func setToCache(filePath string, data string) error {
 return ioutil.WriteFile(filePath, []byte(data), 0644)
}

func main() {
 key := "testKey"
 filePath := cacheDir + "/" + key

 // 创建缓存目录
 os.MkdirAll(cacheDir, os.ModePerm)

 // 设置缓存
 err := setToCache(filePath, "testValue")
 if err != nil {
  fmt.Println("Error setting cache:", err)
  return
 }

 // 获取缓存
 if val, err := getFromCache(filePath); err == nil {
  fmt.Println("Cache hit:", val)
 } else {
  fmt.Println("Cache miss or error:", err)
 }

 // 模拟缓存过期
 time.Sleep(5 * time.Second)
 if _, err := getFromCache(filePath); err != nil {
  fmt.Println("Cache expired")
 }
}

以上是几种常见的缓存技术在CentOS下使用Go语言实现的示例。根据具体需求选择合适的缓存方式，并结合实际情况进行优化和扩展。