Question

我的数据包含user_id和这些用户ID的标签。 user_ids多次出现并且具有预先指定数量的标记（500），但是可能在该特征中发生变化。必须存储的是user_id，它们的标签和它们的数量。我希望以后能够轻松找到最高分的标签..等。每次出现标签时都会增加

我在redis中的实现是使用有序集

完成的

每个user_id都是一个有序集
key是user_id，是十六进制数

的工作原理如下：

zincrby user_id：x 1“tag0”

zincrby user_id：x 1“tag499”

zincrby user_id：y 1“tag3”

等等

考虑到我想获得得分最高的标签，有更好的方法吗？

第二个问题是，现在我正在使用“keys *”来检索客户端操作的这些密钥，我知道它不是针对生产系统的。

另外，对于内存问题来说，迭代指定数量的键（范围为10000）会很棒。我知道密钥必须存储在内存中，但它们不会跟随一个特定的模式，允许部分检索，所以我可以避免“zmalloc”错误（4GB 64位debian服务器）。钥匙数量达到2000万。有什么想法吗？

Answer 1

我的第一点是要注意，4 GB很难存储20M排序集。快速尝试显示，20M用户，每个用户有20个标签，在64位盒子上大约需要8 GB（并且它考虑了Redis 2.4提供的有序集合ziplist内存优化 - 甚至不用早期版本试用）

排序集是支持您的用例的理想数据结构。我会像你描述的那样使用它们。

正如您所指出的，KEYS不能用于迭代键。它更像是一个调试命令。要支持密钥迭代，您需要添加数据结构以提供此访问路径。 Redis中唯一可以支持迭代的结构是列表和排序集（通过范围方法）。但是，它们倾向于将O（n）迭代算法转换为O（n ^ 2）（用于列表）或O（nlogn）（用于zset）。列表也是存储密钥的不良选择，因为在添加/删除密钥时很难维护它。

更有效的解决方案是添加由常规集合组成的索引。您需要使用哈希函数将特定用户与存储桶相关联，并将用户ID添加到与此存储桶对应的集合中。如果用户id是数值，则简单的模数函数就足够了。如果不是这样，一个简单的字符串散列函数就可以解决这个问题。

所以为了支持用户迭代：1000，用户：2000和用户：1001，让我们选择一个模数1000函数。 user：1000和user：2000将放入bucket index：0，而user：1001将放入bucket index：1。

因此，在zsets之上，我们现在有以下键：

index:0 => set[ 1000, 2000 ]
index:1 => set[ 1001 ]

在集合中，不需要键的前缀，并且它允许Redis通过序列化集来优化内存消耗，前提是它们保持足够小（Sripathi Krishnan提出的整数集优化）。

全局迭代包括从0到1000（不包括）的桶上的简单循环。对于每个存储桶，应用SMEMBERS命令来检索相应的集合，然后客户端可以迭代各个项目。

这是Python中的一个例子：

#!/usr/bin/env python
# -*- coding: utf-8 -*-
# ----------------------------------------------------

import redis, random

POOL = redis.ConnectionPool(host='localhost', port=6379, db=0)

NUSERS = 10000
NTAGS = 500
NBUCKETS = 1000

# ----------------------------------------------------
# Fill redis with some random data

def fill(r):
  p = r.pipeline()
  # Create only 10000 users for this example
  for id in range(0,NUSERS):
    user = "user:%d" % id
    # Add the user in the index: a simple modulo is used to hash the user id
    # and put it in the correct bucket
    p.sadd( "index:%d" % (id%NBUCKETS), id )
    # Add random tags to the user
    for x in range(0,20):
      tag = "tag:%d" % (random.randint(0,NTAGS))
      p.zincrby( user, tag, 1 )
    # Flush the pipeline every 1000 users
    if id % 1000 == 0:
      p.execute()
      print id
  # Flush one last time
  p.execute()

# ----------------------------------------------------
# Iterate on all the users and display their 5 highest ranked tags

def iterate(r):
  # Iterate on the buckets of the key index
  # The range depends on the function used to hash the user id
  for x in range(0,NBUCKETS):
    # Iterate on the users in this bucket
    for id in r.smembers( "index:%d"%(x) ):
      user = "user:%d" % int(id)
      print user,r.zrevrangebyscore(user,"+inf","-inf", 0, 5, True )

# ----------------------------------------------------
# Main function

def main():
  r = redis.Redis(connection_pool=POOL)
  r.flushall()
  m = r.info()["used_memory"]
  fill(r)
  info = r.info()
  print "Keys: ",info["db0"]["keys"]
  print "Memory: ",info["used_memory"]-m
  iterate(r)

# ----------------------------------------------------

main()

通过调整常量，您还可以使用此程序来评估此数据结构的全局内存消耗。

IMO这种策略简单而有效，因为它提供了添加/删除用户的O（1）复杂性，以及迭代所有项目的真实O（n）复杂性。唯一的缺点是密钥迭代顺序是随机的。

Redis排序集和存储uid的最佳方式

1 个答案: