提供了编程的基础技术教程

zl程序教程

您现在的位置是：首页 >  Java

当前栏目

给hash表分片：降低锁粒度，提高锁性能

2023-02-18 16:30:48 时间

锁就像漏斗，将并发处理的多个线程变成串行化的模式，我们可以构建一个支持成千上万并发的系统，但是如果锁处理的不好会严重影响系统的性能，就像拥有多条车道的高速公路变成了单行道。

举个例子，假如我们使用go的map来实现一个简单的缓存，由于map不是并发安全,所以我们还要借助sync包的锁来保证并发安全，于是我们很容易写出下面这样的代码：

package simple_cache
​
import (
  "sync"
)
​
type Cache struct {
  items map[string][]byte
  lock  *sync.RWMutex
}
​
func New() *Cache {
  return &Cache{
    items: make(map[string][]byte, 2000),
    lock:  new(sync.RWMutex),
  }
}
​
func (c *Cache) Get(key string) []byte {
  // 取数据只要加读锁
  c.lock.RLock()
  defer c.lock.RUnlock()
  return c.items[key]
}
​
func (c *Cache) Set(key string, data []byte) {
  c.lock.Lock()
  defer c.lock.Unlock()
  c.items[key] = data
}
​

这段代码考虑到了锁其实已经算是不错了，但是每次调用set()方法去设置缓存值的时候不仅将并发读写变成了串行化的模式，就连get()方法也会被阻塞住。在实际生产中使用这段代码作为缓存的时候，map中会缓存大量数据，set()调用可能会很频繁，而且在set()内还需要判断缓存的容量是否足够，这些都会使锁的时间变长。

然后我们不得不考虑如何优化一下锁的性能。上面代码的问题是每次set()都锁住了整个map,于是我们就想到能不能只锁住一部分，这样就能降低锁对性能的消耗。我们可以把原先这个大的缓存分成若干个小的分片，每个分片就是原先的一个Cache,然后再将这些分片放入一个大的map中，根据缓存key值通过hash计算后的值找到对应的分片。对上面代码改造如下：

package simple_cache
​
import (
  "crypto/sha1"
  "fmt"
  "sync"
)
​
type Cache map[string]*ShardCache
​
type ShardCache struct {
  items map[string][]byte
  lock  *sync.RWMutex
}
​
func NewCache() *Cache {
  cache := make(Cache, 256)
  for i := 0; i < 256; i++ {
    cache[fmt.Sprintf("%02x", i)] = &ShardCache{
      items: make(map[string][]byte, 2000),
      lock:  new(sync.RWMutex),
    }
  }
  return &cache
}
​
func (c Cache) getShard(key string) *ShardCache {
  hasher := sha1.New()
  hasher.Write([]byte(key))
        // 转16进制后取前两位
  shardKey := fmt.Sprintf("%x", hasher.Sum(nil))[0:2]
  return c[shardKey]
}
​
func (c Cache) Get(key string) []byte {
  // 取数据只要加读锁
  shard := c.getShard(key)
  shard.lock.RLock()
  defer shard.lock.RUnlock()
  return shard.items[key]
}
​
func (c Cache) Set(key string, data []byte) {
  shard := c.getShard(key)
  shard.lock.Lock()
  shard.lock.Unlock()
  shard.items[key] = data
}

这里我们一共给缓存设置了256（16^2）个分片，对于任意的一个缓存key值经过hash后通过fmt.Sprintf("%x", hasher.Sum(nil))[0:2]转16进制后取前两位后都能在缓存中找到对应的分片

其实像java里面的ConcurrencyHashmap已经是这样做的了，我们通过hash计算数据存储的所在的分片，虽然消耗一点点计算资源但是解决了锁粒度大导致的锁性能问题，这是很值得的。

总结

  • 通过对hash表分片，大锁拆小锁，降低锁粒度，提高高并发情况下的锁性能

相关文章