在Redis中寻找高内存使用的扩展

Question

我们有大量数据存储在Redis中。 实际上，我们在Redis中存储了大量的密钥 ，并且与每个密钥相关联的数据很少 。 密钥长8个字节，数据长8个字节（长值）。 有10亿个密钥（是的，十亿个）。

根据Redis存储的结构，据我所知（ https://redislabs.com/blog/redis-ram-ramifications-part-i/和https://github.com/antirez/sds/blob/ master / README.md ）给定8个字节的密钥，密钥头的开销为8个字节，而空值的开销为1个字节。 那是17个字节。 假设这至少舍入为24个字节，则将8个字节的long值相加得到32个字节。

十亿个密钥将为32GB。 实际使用量为158GB。 当然会有开销，但是5：1的比例似乎很大。 任何人都可以解释这一点或指出减少内存使用的方法。

我已经包括了基于Jedis的测试程序。

import java.security.SecureRandom;
import java.text.DecimalFormat;
import java.util.Date;
import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

import org.apache.commons.pool2.impl.GenericObjectPoolConfig;

import redis.clients.jedis.HostAndPort;
import redis.clients.jedis.JedisCluster;
import redis.clients.jedis.exceptions.JedisClusterMaxRedirectionsException;

public class Test8byteKeys {
    protected static JedisCluster cluster = null;
    protected static final ExecutorService executor;

    protected static volatile boolean shuttingDown = false;

    private static final int AVAILABLE_PROCESSORS = Runtime.getRuntime().availableProcessors();

    static {
        final int cores = Math.max(4, (AVAILABLE_PROCESSORS * 3) / 4);
        executor = new ThreadPoolExecutor(cores, cores, //
                15, TimeUnit.SECONDS, //
                new LinkedBlockingQueue<>(cores), //
                new ThreadPoolExecutor.CallerRunsPolicy());

        System.out.println("Running with " + cores + " threads");
    }

    static private GenericObjectPoolConfig getPoolConfiguration() {
        GenericObjectPoolConfig poolConfig = new GenericObjectPoolConfig();

        poolConfig.setLifo(true);
        poolConfig.setTestOnBorrow(true);
        poolConfig.setTestOnReturn(false);
        poolConfig.setBlockWhenExhausted(true);
        poolConfig.setMinIdle(1);
        poolConfig.setMaxTotal(101);
        poolConfig.setTestWhileIdle(false);
        poolConfig.setSoftMinEvictableIdleTimeMillis(3000L);
        poolConfig.setNumTestsPerEvictionRun(5);
        poolConfig.setTimeBetweenEvictionRunsMillis(5000L);
        poolConfig.setJmxEnabled(true);

        return poolConfig;
    }

    private static void connectToCluster() {
        try {
            Set<HostAndPort> nodes = new HashSet<>();
            String hap /* host and port */ = System.getProperty("hap", null);
            if (hap == null) {
                System.err.println("You must supply the host and port of a master in the cluster on the command line");
                System.err.println("java -Dhap=<host:port> -jar <jar> ");
                System.exit(1);
            }

            String[] parts = hap.split(":"); // assume ipv4 address
            nodes.add(new HostAndPort(parts[0].trim(), Integer.valueOf(parts[1].trim())));

            System.out.println("Connecting to " + hap);
            cluster = new JedisCluster(nodes, getPoolConfiguration());
        }
        catch (Exception e) {
            System.err.println("Could not connect to redis -- " + e.getMessage());
            System.exit(1);
        }
    }

    private static final Thread shutdown = new Thread(new Runnable() {
        // Clean up at exit
        @Override
        public void run() {
            shuttingDown = true;

            System.out.println((new Date()).toString() + "\t" + "Executor shutdown in progress");

            try {
                executor.shutdown();
                executor.awaitTermination(10L, TimeUnit.SECONDS);
            }
            catch (Exception e) {
                // ignore
            }
            finally {
                try {
                    if (!executor.isShutdown()) {
                        executor.shutdownNow();
                    }
                }
                catch (Exception e) {
                    //ignore
                }
            }

            try {
                cluster.close();
            }
            catch (Exception e) {
                System.err.println("cluster disconnection failure: " + e);
            }
            finally {
                //
            }

            System.out.println((new Date()).toString() + "\t" + "shutdown complete.");
        }
    });

    final static char[] CHARACTERS = { //
            '0', '1', '2', '3', '4', '5', //
            '6', '7', '8', '9', 'a', 'b', //
            'c', 'd', 'e', 'f', 'g', 'h', //
            'i', 'j', 'k', 'l', 'm', 'n', //
            'o', 'p', 'q', 'r', 's', 't', //
            'u', 'v', 'w', 'x', 'y', 'z', //
            'A', 'B', 'C', 'D', 'E', 'F', //
            'G', 'H', 'I', 'J', 'K', 'L', //
            'M', 'N', 'O', 'P', 'Q', 'R', //
            'S', 'T', 'U', 'V', 'W', 'X', //
            'Y', 'Z', '#', '@' //
    };

    protected final static byte[] KEY_EXISTS_MARKER = { '1' };

    static class Runner implements Runnable {
        private byte[] key = null;

        public Runner(byte[] key) {
            this.key = key;
        }

        @Override
        public void run() {
            if (!shuttingDown) {
                try {
                    cluster.set(key, KEY_EXISTS_MARKER);
                    cluster.expire(key, 60 * 60 * 48); // for test purposes, only keep around for 2 days
                }
                catch (JedisClusterMaxRedirectionsException e) {
                    System.err.println(
                            (new Date()).toString() + "\tIGNORING\t" + e + "\t" + "For key " + new String(key));
                }
                catch (Exception e) {
                    System.err.println((new Date()).toString() + "\t" + e + "\t" + "For key " + new String(key));
                    e.printStackTrace();
                    System.exit(1);
                }
            }
        }
    }

    public static void main(String[] args) {
        SecureRandom random = new SecureRandom();
        DecimalFormat decimal = new DecimalFormat("#,##0");
        final byte[] randomBytes = new byte[8];

        connectToCluster();

        Runtime.getRuntime().addShutdownHook(shutdown);

        System.out.println((new Date()) + " Starting test");

        for (int i = 0; i < 1000000000; i++) {
            random.nextBytes(randomBytes);
            final byte[] key = new byte[8];
            for (int j = 0; j < randomBytes.length; j++)
                key[j] = (byte) (CHARACTERS[((randomBytes[j] & 0xFF)) % CHARACTERS.length] & 0xFF);

            try {
                if (shuttingDown) {
                    System.err.println((new Date()).toString() + "\t" + "Main loop terminating due to shutdown");
                    break;
                }

                if (i % 1000000 == 0)
                    System.out.println((new Date()).toString() + "\t" + decimal.format(i));

                try {
                    executor.submit(new Runner(key));
                }
                catch (Exception e) {
                    System.err.println((new Date()).toString() + "\t" + e);
                }
            }
            catch (Exception e) {
                System.err.println("Failed to set key " + new String(key) + " -- " + e);
            }
        }

        if (!shuttingDown) {
            System.out.println((new Date()) + " Done");
            System.exit(0);
        }
    }
}

Answer 1

几乎每个内存管理器都会为分配的每个对象带来内部开销，只是为了跟踪对象。 例如：当您调用free（）时，内存管理器可能需要有关该对象的一些信息，以确定该对象所属的内存池/页面。 小对象可能会落入一个池中，并使用与大对象不同的分配机制。

与Redis sds.c / sds.h的工作原理非常相似，堆管理器通常还将其自身的结构添加到每个malloc（）对象。

如果堆的每个对象的开销为16字节，那么将其添加到每个10KB的malloc（）中将是不可察觉的开销。 但是，如果您正在谈论Redis中的8字节密钥，那么为每个8字节密钥增加16个字节的开销将超出密钥本身的内存。

您可以在此处找到有关malloc块和fastbin的更多信息： http ://iarchsys.com/?p=764

快速而肮脏地检查此开销的方法是将密钥从8个字节增加到16个字节。尽管您将密钥使用的内存大小加倍，但是您可能不会看到Redis进程消耗的内存增加一倍。

Answer 2

这需要更深入的分析，但是很明显的一件事是，开销计算是错误的（很可能是我没有完成博客系列的错-对不起；）。

Redis中的每个键（无论其类型/名称/值）都有开销。 v3.2.10的开销IIRC约为70个字节。 但是，该开销是在较小的数据集（远远少于1B密钥）上测量的，如果我没有记错的话，更大的全局词典将为每个密钥带来更多开销。 再加上该值本身及其字符串开销，您可以轻松获得80个字节，总容量约为80GB。

也就是说，如果不在实验室中实际重新创建x2因子，我将无法解释。 集群可能需要考虑其他开销。 我建议您从较小的数据集开始，并比较独立内存和群集内存的使用情况，作为下一步调查。 另外，您可能要针对最新版本的Redis（4）进行测试，因为它包含与内存使用相关的多项优化。

Answer 3

您应该考虑将Ur Redis实例划分为多个实例