KeyLock 我做一个简单的开源库，可以用在防止缓存雪崩的读缓存的最佳实践之一中

技术背景

众所周知，为了提高了性能，我们会在数据库层前面加一个读缓存(redis or Memcached)。但是如果在高并发时候，有很多个请求，正好请求同一个值，而该值的缓存正好失效或者不在缓存中，就会导致这些很多请求都变成数据库查询。这就是缓存雪崩。

为了解决这种问题，常见的思路就是给请求查缓存时加锁，最多只允许有一个请求查询数据库。

比如有getProduct查商品 ID 为 1000 的商品的伪代码

  func getProduct(id:string) (product,error) {
  	  // 用 id 锁住
      // 从缓存中查
      // 查到就释放锁返回值
    
      // 没有查到就查数据库
      // 放到缓存中，释放锁，返回值
  }

KeyLock

但是在 Golang 语言中，我找了一下没有找到现有的库，所以我自己做一个简单的 keylock 的开源库。

https://github.com/CorrectRoadH/keylock

现在有提供两种锁，一种是单体应用中的锁，另一种适合分布式服务中的分布式锁，需要 redis 。

这里提供一个单体应用中的 key 锁的简单的 demo

  type UserService struct {
  	store *store.UserStore
  	cache *user.UserCacheAdapter
  	apiv1pb.UnimplementedUserServiceServer
  	keylock keylock.KeyLock
  }
  
  func NewUserService(store *store.UserStore, cache *user.UserCacheAdapter) *UserService {
      keylock,err := keylock.New()
      if err != nil {
          fmt.Println(err)
      }
  	return &UserService{
  		store:   store,
  		cache:   cache,
  		keylock: keylock,
  	}
  }
  
  func (s *UserService) UpsertUser(ctx context.Context, req *apiv1pb.UpsertUserRequest) (*apiv1pb.User, error) {
  	s.cache.DeleteCache(ctx, req.User.Id) // 修改数据库之前删一次缓存
  	user, err := s.store.UpsertUser(ctx, convertUser(req.User))
  	s.cache.DeleteCache(ctx, req.User.Id) // 修改数据库之后再删一次缓存
  
  	if err != nil {
  		return nil, err
  	}
  	return convertUserPb(user), nil
  }
  
  func (s *UserService) GetUser(ctx context.Context, req *apiv1pb.GetUserRequest) (*apiv1pb.User, error) {
  	// 在查询缓存前先通过 UserId 锁住，最多允许一个线程进入数据库，防止缓存雪崩
  	s.keylock.Lock(req.Id)
  	defer s.keylock.Unlock(req.Id)
  
  	user, err := s.cache.User(ctx, req.Id)
  	if err == nil {
  		return convertUserPb(user), nil
  	}
  
  	user, err = s.store.User(ctx, req.Id)
  	if err != nil {
  		return nil, status.Error(codes.NotFound, err.Error())
  	}
  
  	s.cache.UpsertUser(ctx, user)
  	return convertUserPb(user), nil
  }

如果觉得这个库有用的话，不妨给我点个 Star🌟

点个 Star 呗